Add project files.

This commit is contained in:
Ankitkumar Satapara
2026-04-17 22:31:58 +05:30
commit 21aaef6776
473 changed files with 50152 additions and 0 deletions

View File

@@ -0,0 +1,147 @@
Connections are created between two points. The `Source` and `Target` dependency properties are of type `Point` and are usually bound to a connector's `Anchor` point.
## Table of contents
- [Base connection](#base-connection)
- [Line connection](#line-connection)
- [Circuit connection](#circuit-connection)
- [Bezier connection](#connection)
- [Step connection](#step-connection)
- [Pending connection](#pending-connection)
- [Custom connection](#custom-connection)
## Using connections
In the `NodifyEditor`, you can customize both the default connection and the pending connection by assigning a custom `DataTemplate` to the `ConnectionTemplate` and `PendingConnectionTemplate` properties, respectively.
- `ConnectionTemplate`: defines the appearance of established connections between nodes.
- `PendingConnectionTemplate`: specifies the visual appearance of connections that are in the process of being created (i.e., while the connection is being dragged but not yet completed).
To customize these, simply set your desired `DataTemplate` on the `NodifyEditor` instance.
## Base connection
The base class for all connections provided by the library is `BaseConnection` which derives from `Shape`. There's no restriction to derive from `BaseConnection` when you create a custom connection.
It exposes two commands with their corresponding events:
- `DisconnectCommand`, respectively `DisconnectEvent` - fired when the connection is clicked while holding `ALT`
- `SplitCommand`, respectively `SplitEvent` - fired when the connection is double-clicked
The `Direction` of a connection can have two values:
- `Forward`
![image](https://user-images.githubusercontent.com/12727904/192101918-af9b0da6-ecc8-48f7-bf4d-8f9fdd005153.png)
![image](https://user-images.githubusercontent.com/12727904/192101959-2cb9a837-1642-4e96-b2ef-eea5502a587f.png)
- `Backward`
![image](https://user-images.githubusercontent.com/12727904/192101941-a00e23db-07ae-49ac-a907-72e35ef67877.png)
![image](https://user-images.githubusercontent.com/12727904/192101977-1afd69f1-dab0-478e-9c3d-7d601486c289.png)
The `SourceOffset` and the `TargetOffset` work together with `OffsetMode` and will keep a distance from the anchor point:
![image](https://user-images.githubusercontent.com/12727904/192102096-b20887d5-b7ba-450f-9cf3-7fa4086d9637.png)
Connections also have a `Spacing` which will make the connection break the angle at a certain distance from the `Source` and `Target` points:
- With spacing:
![image](https://user-images.githubusercontent.com/12727904/192102286-9a79da8e-5e87-4f60-9e82-979bfabcd6f3.png)
- Without spacing:
![image](https://user-images.githubusercontent.com/12727904/192102302-4125b44a-dfad-4d9e-9131-efb7c17cefbe.png)
Settings the `ArrowSize` to "0, 0" will remove the arrowhead.
## Line connection
A straight line from `Source` to `Target`.
![image](https://user-images.githubusercontent.com/12727904/192115137-d8d2145b-a769-4ee9-b4e0-8a362c94e9e7.png)
## Circuit connection
It has an `Angle` dependency property to control where it breaks. Angle is in degrees.
![image](https://user-images.githubusercontent.com/12727904/192115226-b0e515b4-5a21-46aa-956a-401f07b7d308.png)
## Connection
A bezier curve between `Source` and `Target`.
![image](https://user-images.githubusercontent.com/12727904/192115259-2fe56a68-b3e4-4f5d-aa5c-5ab83e84a84d.png)
## Step connection
A multi-segment angled wire between `Source` and `Target`. It has two additional parameters: `SourcePosition` and `TargetPosition`.
![image](https://github.com/user-attachments/assets/c63d620e-af34-460e-ad9e-b2d9adb748bf)
## Pending Connection
A pending connection can be created from a connector and dropped on either an `ItemContainer` (if `AllowOnlyConnectors` is false) or a `Connector`.
`Content` of a pending connection can be customized using the `ContentTemplate`. If `EnablePreview` is true, the `PreviewTarget` will be updated with the connector or item container under the mouse cursor or `null` if there's no such element.
![image](https://user-images.githubusercontent.com/12727904/192115698-fbe29101-884f-4cec-9c25-e318701d30b1.png)
The visibility of pending connections can be controlled using the `IsVisible` dependency property.
Connection snapping to connectors can be enabled using the `EnableSnapping` dependency property.
The `Source` and the `Target` properties are data contexts of connectors and the `Target` will be updated when the pending connection is completed.
There's also a `StartedCommand` which takes the `Source` as the parameter, respectively a `CompletedCommand` which takes the `Target` as the parameter.
> [!TIP]
> Canceling a pending connection is done by releasing the right mouse button.
## Custom connection
In some cases, the built-in connections may not provide all the features you need, or your application may need to display hundreds of connections simultaneously. While the built-in connections are feature-rich, they may introduce some overhead that could impact performance. In such cases, you can implement a custom connection to better suit your needs.
There are several ways to implement a custom connection:
- Derive from one of the existing connection classes and override the appropriate methods.
- Create a custom control or user control that wraps a built-in connection.
- Implement a custom connection from scratch.
**Considerations for Implementing a Custom Connection from Scratch**
- The cutting line feature requires the connection type to be added to the `NodifyEditor.CuttingConnectionTypes` collection (see [Cuttline Line - Custom Connections](CuttingLine-Overview#custom-connections))
- For selection functionality, you must set the `nodify:BaseConnection.IsSelectable` attached property to `true` on the root element.
- To control the selection state, bind to the `nodify:BaseConnection.IsSelected` attached property on the root element.
Example:
```xml
<Line X1="{Binding Source.Anchor.X}"
X2="{Binding Target.Anchor.X}"
Y1="{Binding Source.Anchor.Y}"
Y2="{Binding Target.Anchor.Y}"
StrokeThickness="5"
nodify:BaseConnection.IsSelectable="True"
nodify:BaseConnection.IsSelected="{Binding IsSelected}">
<Line.Style>
<Style TargetType="Line">
<Setter Property="Stroke"
Value="Red" />
<Style.Triggers>
<Trigger Property="nodify:BaseConnection.IsSelected"
Value="True">
<Setter Property="Stroke"
Value="Green" />
</Trigger>
<Trigger Property="nodify:BaseConnection.IsSelectable"
Value="True">
<Setter Property="Cursor"
Value="Hand" />
</Trigger>
</Style.Triggers>
</Style>
</Line.Style>
</Line>
```

View File

@@ -0,0 +1,10 @@
The connector creates a pending connection by raising the `PendingConnectionStartedEvent` event. Connectors have an `Anchor` dependency property that **must** be bound in order to be able to create connections between them that are updated in real-time when the node's position changes. The `IsConnected` dependency property **must** be set to true in order to receive `Anchor` updates.
ALT+Click on a connector fires the `DisconnectCommand`.
## NodeInput and NodeOutput
Node input and node output are implementations of `Connector` with a `Header` that can be used to display text or input boxes by customizing the `HeaderTemplate`. They also expose a `ConnectorTemplate` to customize the connector itself. They are usually used in conjunction with `Node.InputConnectorTemplate` and `Node.OutputConnectorTemplate`.
![image](https://user-images.githubusercontent.com/12727904/192117525-a7e1b309-70d6-4ed7-bcd7-8210dbd680ce.png)

View File

@@ -0,0 +1,63 @@
## Table of contents
- [Enabling preview](#enabling-preview)
- [Custom connections](#custom-connections)
- [Customization](#customization)
The `CuttingLine` control is a custom control used to remove intersecting connections.
The default gesture to start cutting is `SHIFT+ALT+LeftClick` and can be configured by setting the `EditorGestures.Editor.Cutting` gesture. The cutting can be canceled by pressing the `Escape` key or the right mouse button which can be configured by setting the `EditorGestures.Editor.CancelAction` gesture.
Relevant commands available in `NodifyEditor`:
- CuttingStartedCommand
- CuttingCompletedCommand
- RemoveConnectionCommand - is called for each intersecting connection when the cutting operation is completed
## Enabling preview
For the connection style to change when intersecting with the cutting line, it's required to set `NodifyEditor.EnableCuttingLinePreview` to `true`.
> [!WARNING]
> Depending on the number of connections and the complexity of their geometry, this may have a great performance impact.
![cutting](https://github.com/user-attachments/assets/22f705c8-3bf1-466b-8bbd-da007f30deb2)
## Custom connections
To enable cutting custom connections you must add the connection type to `NodifyEditor.CuttingConnectionTypes`:
```csharp
// example adding the Line shape to the connection types that can be cut
NodifyEditor.CuttingConnectionTypes.Add(typeof(System.Windows.Shapes.Line));
```
The style of the intersecting custom connection can be customized as follows:
```xml
<Style TargetType="Line">
<Style.Triggers>
<Trigger Property="nodify:CuttingLine.IsOverElement" Value="True">
<Setter Property="Opacity"
Value="0.4" />
</Trigger>
</Style.Triggers>
</Style>
```
## Customization
The `CuttingLineStyle` is used to customize the cutting line:
```xml
<Style x:Key="CuttingLineStyle"
TargetType="{x:Type nodify:CuttingLine}"
BasedOn="{StaticResource {x:Type nodify:CuttingLine}}">
<Setter Property="StrokeDashArray"
Value="1 1" />
<Setter Property="StrokeThickness"
Value="2" />
</Style>
<nodify:NodifyEditor CuttingLineStyle="{StaticResource CuttingLineStyle}" ... />
```

5
docs/Documentation.md Normal file
View File

@@ -0,0 +1,5 @@
# Documentation
While the documentation is a work in progress, I encourage you to check out the [example application](https://github.com/miroiu/nodify/tree/master/Examples/Nodify.Playground).
![Example Application](https://i.imgur.com/gpcllLy.png)

143
docs/Editor-Overview.md Normal file
View File

@@ -0,0 +1,143 @@
## Table of contents
- [Moving the viewport](#panning)
- [Zooming](#zooming)
- [Scrolling](#scrolling)
- [Selecting items](#selecting)
- [Selection API](#selection-api)
- [Snapping to grid](#snapping)
- [Pushing items](#pushing-items)
- [Commands](#commands)
- [Editor API](#editor-api)
## Panning
Panning is done by holding right-click and moving the mouse and can be disabled by setting the `DisablePanning` dependency property to `true`.
> Note: It can be programmatically changed by setting the `ViewportLocation` dependency property.
While panning, the `IsPanning` dependency property will be set to `true` and the `ViewportSize`, `ViewportLocation` and `ViewportTransform` dependency properties will be updated.
Automatic panning is also enabled by default and can be disabled by setting the `DisableAutoPanning` dependency property to `true`. The behavior is to pan the viewport when selecting or dragging a selection or a pending connection near the edges of the viewport.
The auto panning speed can be changed using the `AutoPanSpeed` dependency property and the distance from the edge to trigger the panning can be changed using the `AutoPanEdgeDistance` dependency property.
Panning can also be used in combination with selecting and zooming while auto panning can be used with both selecting and zooming and also with dragging a selection or a pending connection.
Default values:
- `DisablePanning`: false
- `DisableAutoPanning`: false
- `AutoPanSpeed`: 10 pixels per tick
- `AutoPanEdgeDistance`: 15 pixels
- `AutoPanningTickRate`: 1 millisecond
## Zooming
Zooming is done by using the mouse wheel or by pressing `CTRL +` to zoom in or `CTRL -` to zoom out and can be disabled by setting the `DisableZooming` dependency property to `true`.
> Note: It can be programmatically changed by setting the `ViewportZoom` dependency property to a value between `MinViewportZoom` and `MaxViewportZoom`.
While zooming, the `ViewportLocation`, `ViewportSize` and `ViewportTransform` dependency properties will be updated.
Zooming can also be used in combination with panning, dragging a selection, or a pending connection.
Default values:
- `ViewportZoom`: 1
- `MinViewportZoom`: 0.1
- `MaxViewportZoom`: 2
## Scrolling
Wrap the `NodifyEditor` inside a `ScrollViewer` to enable scrolling:
```xml
<ScrollViewer CanContentScroll="True">
<nodify:NodifyEditor ... />
<ScrollViewer>
```
The scroll sensitivity can be adjusted by setting the `ScrollIncrement` static field.
Default values:
- `ScrollIncrement`: `Mouse.MouseWheelDeltaForOneLine` / 2
## Selecting
Selecting items is done by holding the left mouse button and moving the mouse. When a selection operation is in progress, the `IsSelecting` dependency property is set to `true` and the `SelectedArea` dependency property is updated with each move.
> Note: Selected items can also be set programmatically by binding a collection to the `SelectedItems` dependency property.
If real-time selection is enabled (`EnableRealtimeSelection`: true), the items will be selected and deselected while you resize the selection rectangle. Otherwise, the items contained in the `SelectedArea` will only be selected after the selection operation is finished.
When an `ItemContainer` is selected, its `IsSelected` dependency property is set to `true`.
Different behavior is used depending on the `ModifierKeys` held when starting a selection:
- `Replace` - no modifier key (default behavior, clears the selected items and starts a new selection)
- `Append` - shift key (adds selection to the currently selected items)
- `Remove` - alt key (removes selection from the currently selected items)
- `Invert` - control key (removes selected items and adds unselected items)
Selecting items can also be used in combination with panning and zooming.
Default values:
- `EnableRealtimeSelection`: true
### Selection API
The following methods can be called on a NodifyEditor instance.
- SelectAll
- UnselectAll
- SelectArea
- InvertSelection
- UnselectArea
- SelectAllConnections
- UnselectAllConnections
## Snapping
When a selection is moved the `GridCellSize` dependency property will be used to determine where to snap the selected items.
The snapping is relative to the position of the selected item and not the virtual grid.
If the selected items are not snapped to the grid when they are initially created or if the `GridCellSize` is changed at runtime, the final position will be corrected after moving the selection if the `EnableSnappingCorrection` dependency property is `true`.
Default values:
- `GridCellSize`: 1
- `EnableSnappingCorrection`: true
## Pushing Items
The Pushing Items feature allows users to interactively move items within the editor by performing a drag gesture.
To initiate the push operation, hold `CTRL+SHIFT` and click with the **Left Mouse Button**. During the push items operation, the `IsPushingItems` dependency property is set to `true`, the `PushOrientation` dependency property is initialized with the direction the user is dragging, and the `PushedArea` dependency property updates in real time to reflect the interaction state.
To cancel the push operation, press the `Escape` key or release `CTRL+SHIFT` and click the **Right Mouse Button**. You can configure the default keybindings by modifying the `EditorGestures.Editor.PushItems` gesture. To prevent cancellation, set `NodifyEditor.AllowPushItemsCancellation` to `false`.
The visual appearance of the push area can be customized by setting the `PushedAreaStyle` property.
## Commands
The following `RoutedUICommand`s are found in the `EditorCommands` class:
- `ZoomIn` - `CTRL +` (zoom in relative to the viewport's center)
- `ZoomOut` - `CTRL -` (zoom out relative to the viewport's center)
- `SelectAll` - `CTRL A` (select all items)
- `BringIntoView` - Moves the viewport to the specified location, defaults to [0,0]. (`CommandParameter` is the location of type `Point` or `string`)
- `Align` - Aligns the selected items using the specified alignment method, defaults to Top. (`CommandParameter` is of type `Alignment` or `string`. Possible alignment: Top, Left, Bottom, Right, Middle, Center)
- `FitToScreen` - Scales and moves the `Viewport` to display as many items as possible
## Editor API
You can programmatically call the corresponding methods of these commands on an instance of a `NodifyEditor`.
- FitToScreen
- BringIntoView
- ZoomAtPosition
- ZoomIn
- ZoomOut

79
docs/FAQ.md Normal file
View File

@@ -0,0 +1,79 @@
#### Q: Why is the connection not following the connectors when I move a node?
A1: You didn't bind the `Anchor` of the connector, or the `Source` and `Target` properties of the connection.
A2: The `Anchor` of the connectors updates only if the `IsConnected` property is set to true.
***
#### Q: Can I change the mouse/key bindings?
A: Yes! You can configure the [editor gestures](https://github.com/miroiu/nodify/blob/master/Nodify/EditorGestures.cs) to your liking.
***
#### Q: Would there be an Avalonia port?
A: There is a fantastic Avalonia port available! You can check it out [here](https://github.com/BAndysc/nodify-avalonia). Huge thanks to [BAndysc](https://github.com/BAndysc) who made this possible.
***
#### Q: Is there a non-MVVM approach to adding nodes and connections?
A: No.
***
#### Q: How can I set the selected nodes to be always on top?
A: https://github.com/miroiu/nodify/issues/57
***
#### Q: How can I change the size of a node?
A: https://github.com/miroiu/nodify/issues/55
***
#### Q: How can I limit the X and Y panning?
A: https://github.com/miroiu/nodify/issues/53
***
#### Q: The viewport is lagging. How can I fix it?
A: https://github.com/miroiu/nodify/issues/60
***
#### Q: How can I drag nodes from a toolbox into the editor?
A: https://github.com/miroiu/nodify/issues/81
***
#### Q: How can I create a custom connection?
A: https://github.com/miroiu/nodify/issues/121
***
#### Q: How can I create a custom node?
A: https://github.com/miroiu/nodify/discussions/234
***
#### Q: How can I make the editor read-only?
A: https://github.com/miroiu/nodify/issues/206
***
#### Q: Is there an option for auto layout?
A: https://github.com/miroiu/nodify/issues/73

586
docs/Getting-Started.md Normal file
View File

@@ -0,0 +1,586 @@
It is _important_ to understand how components are named and what's their role in the visual tree of the editor to understand the code and the documentation.
## Hierarchy and terminology
The root component is an [editor](Editor-Overview) which holds [nodes](Nodes-Overview) and [connections](Connections-Overview) together with a few additional UI elements such as a [selection rectangle](Editor-Overview#selecting) and a [pending connection](Connections-Overview#pending-connection) in order to make the editor interactive.
Nodes are containers for [connectors](Connectors-Overview) or the node itself can be a connector (e.g. [State Node](Nodes-Overview#4-the-statenode-control)).
Connectors can create pending connections that can become real connections when completed.
_A picture is worth a thousand words_
![nodes-hierarchy](https://user-images.githubusercontent.com/12727904/192028123-e2847f29-6517-4731-8672-f5d8356dead0.png)
## Content Layers
You may wonder how a node can be a connector itself and still behave like a normal node. The editor contains three big layers which help solve this problem:
1. The items layer (`NodifyEditor.ItemsSource`) - here, each control is wrapped inside an [Item Container](ItemContainer-Overview) making it selectable, draggable, etc and it is possible to have any control rendered (e.g a connector, a text block).
2. The connections layer (`NodifyEditor.Connections`) - this is where all the [connections](Connections-Overview) coexist and are rendered behind the items layer by default
3. The decorators layer (`NodifyEditor.Decorators`) - here, each control is given a location inside the graph
Having those layers separated enables the possibility of asynchronously loading each one of them.
## Using an existing theme
Merge one of the following themes into your resource dictionary in `App.xaml`:
- Dark theme (default theme if not specified):
```xml
<ResourceDictionary Source="pack://application:,,,/Nodify;component/Themes/Dark.xaml" />
```
- Light theme:
```xml
<ResourceDictionary Source="pack://application:,,,/Nodify;component/Themes/Light.xaml" />
```
- Nodify theme:
```xml
<ResourceDictionary Source="pack://application:,,,/Nodify;component/Themes/Nodify.xaml" />
```
## A minimal example
Import the `nodify` namespace: `xmlns:nodify="https://miroiu.github.io/nodify"` or `xmlns:nodify="clr-namespace:Nodify;assembly=Nodify"` in your file and create an instance of the editor `<nodify:NodifyEditor />`. If you start the application, you will see an empty space where you can create a selection rectangle.
> Tip: Drag the selection rectangle near the edge of the editor area and the screen will automatically move in that direction.
### Adding nodes
Now we're going to display a few nodes. Let's create the viewmodels and bind them to the view.
```csharp
public class NodeViewModel
{
public string Title { get; set; }
}
public class EditorViewModel
{
public ObservableCollection<NodeViewModel> Nodes { get; } = new ObservableCollection<NodeViewModel>();
public EditorViewModel()
{
Nodes.Add(new NodeViewModel { Title = "Welcome" });
}
}
```
The view model can be of any shape, but the view for the node is generated by the `ItemTemplate`. (The same result would be achieved by having the DataTemplate inside NodifyEditor.Resources)
```xml
<nodify:NodifyEditor ItemsSource="{Binding Nodes}">
<nodify:NodifyEditor.DataContext>
<local:EditorViewModel />
</nodify:NodifyEditor.DataContext>
<nodify:NodifyEditor.ItemTemplate>
<DataTemplate DataType="{x:Type local:NodeViewModel}">
<nodify:Node Header="{Binding Title}" />
</DataTemplate>
</nodify:NodifyEditor.ItemTemplate>
</nodify:NodifyEditor>
```
Notice how we bind the `Header` of the `Node` to display the `Title`. For more node types and customization please check out the [Nodes overview](Nodes-Overview).
### Connecting nodes
Alright, now let's add more nodes and connect them together. First, we need a representation of a connector and some collections on the node to store our connectors.
```csharp
public class ConnectorViewModel
{
public string Title { get; set; }
}
public class NodeViewModel
{
public string Title { get; set; }
public ObservableCollection<ConnectorViewModel> Input { get; set; } = new ObservableCollection<ConnectorViewModel>();
public ObservableCollection<ConnectorViewModel> Output { get; set; } = new ObservableCollection<ConnectorViewModel>();
}
public class EditorViewModel
{
public ObservableCollection<NodeViewModel> Nodes { get; } = new ObservableCollection<NodeViewModel>();
public EditorViewModel()
{
Nodes.Add(new NodeViewModel
{
Title = "Welcome",
Input = new ObservableCollection<ConnectorViewModel>
{
new ConnectorViewModel
{
Title = "In"
}
},
Output = new ObservableCollection<ConnectorViewModel>
{
new ConnectorViewModel
{
Title = "Out"
}
}
});
}
}
```
And bind them to the view. (We used the built-in `NodeInput` and `NodeOutput` for the view, but there are [other connectors](Connectors-Overview) too. Or you can create your own, depending on your needs.)
```xml
<nodify:Node Header="{Binding Title}"
Input="{Binding Input}"
Output="{Binding Output}">
<nodify:Node.InputConnectorTemplate>
<DataTemplate DataType="{x:Type local:ConnectorViewModel}">
<nodify:NodeInput Header="{Binding Title}" />
</DataTemplate>
</nodify:Node.InputConnectorTemplate>
<nodify:Node.OutputConnectorTemplate>
<DataTemplate DataType="{x:Type local:ConnectorViewModel}">
<nodify:NodeOutput Header="{Binding Title}" />
</DataTemplate>
</nodify:Node.OutputConnectorTemplate>
</nodify:Node>
```
The `Node` control supports `Input` and `Output` connectors and the way you customize these is by overwriting the default template for the `InputConnectorTemplate`, respectively the `OutputConnectorTemplate`.
Clicking and dragging a wire from the `Input` or `Output` connector will create a [pending connection](Connections-Overview#pending-connection) that we can transform into a real connection.
**The most complicated part of Nodify is how you bind the connections to their connectors.** Let's create the ViewModel for the connection and add a list of connections in the `EditorViewModel`.
```csharp
public class ConnectionViewModel
{
public ConnectorViewModel Source { get; set; }
public ConnectorViewModel Target { get; set; }
}
public class EditorViewModel
{
public ObservableCollection<NodeViewModel> Nodes { get; } = new ObservableCollection<NodeViewModel>();
public ObservableCollection<ConnectionViewModel> Connections { get; } = new ObservableCollection<ConnectionViewModel>();
public EditorViewModel()
{
var welcome = new NodeViewModel
{
Title = "Welcome",
Input = new ObservableCollection<ConnectorViewModel>
{
new ConnectorViewModel
{
Title = "In"
}
},
Output = new ObservableCollection<ConnectorViewModel>
{
new ConnectorViewModel
{
Title = "Out"
}
}
};
var nodify = new NodeViewModel
{
Title = "To Nodify",
Input = new ObservableCollection<ConnectorViewModel>
{
new ConnectorViewModel
{
Title = "In"
}
}
};
Nodes.Add(welcome);
Nodes.Add(nodify);
Connections.Add(new ConnectionViewModel
{
Source = welcome.Output[0],
Target = nodify.Input[0]
});
}
}
```
Then update the `ConnectorViewModel` to have an `Anchor` point that the connection can attach to. (This needs to be reactive, so we're gonna implement INotifyPropertyChanged in the view model).
> Note: The `Point` type must be from System.Windows.
```csharp
public class ConnectorViewModel : INotifyPropertyChanged
{
private Point _anchor;
public Point Anchor
{
set
{
_anchor = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Anchor)));
}
get => _anchor;
}
public string Title { get; set; }
public event PropertyChangedEventHandler PropertyChanged;
}
```
Bind the `Anchor` to the connector's view as `Mode=OneWayToSource`. And also set the `IsConnected` to `True` to receive `Anchor` updates.
```xml
<nodify:Node.InputConnectorTemplate>
<DataTemplate DataType="{x:Type local:ConnectorViewModel}">
<nodify:NodeInput Header="{Binding Title}"
IsConnected="True"
Anchor="{Binding Anchor, Mode=OneWayToSource}" />
</DataTemplate>
</nodify:Node.InputConnectorTemplate>
<nodify:Node.OutputConnectorTemplate>
<DataTemplate DataType="{x:Type local:ConnectorViewModel}">
<nodify:NodeOutput Header="{Binding Title}"
IsConnected="True"
Anchor="{Binding Anchor, Mode=OneWayToSource}" />
</DataTemplate>
</nodify:Node.OutputConnectorTemplate>
```
And bind the connections to the view and let them use our `ConnectorViewModel`'s `Anchor` in the `ConnectionTemplate`. For more customization, please refer to [connections overview](Connections-Overview).
```xml
<nodify:NodifyEditor ItemsSource="{Binding Nodes}"
Connections="{Binding Connections}">
...
<nodify:NodifyEditor.ConnectionTemplate>
<DataTemplate DataType="{x:Type local:ConnectionViewModel}">
<nodify:LineConnection Source="{Binding Source.Anchor}"
Target="{Binding Target.Anchor}" />
</DataTemplate>
</nodify:NodifyEditor.ConnectionTemplate>
...
```
If you start the application now, you'll see that there is a connection and if you drag the nodes around, it will follow them.
Now let's add the `IsConnected` property to the `ConnectorViewModel` so we can set it whenever it is truly connected or not. And update the `ConnectionViewModel` to connect them automatically on construction.
```csharp
public class ConnectorViewModel : INotifyPropertyChanged
{
private Point _anchor;
public Point Anchor
{
set
{
_anchor = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Anchor)));
}
get => _anchor;
}
private bool _isConnected;
public bool IsConnected
{
set
{
_isConnected = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsConnected)));
}
get => _isConnected;
}
public string Title { get; set; }
public event PropertyChangedEventHandler PropertyChanged;
}
public class ConnectionViewModel
{
public ConnectionViewModel(ConnectorViewModel source, ConnectorViewModel target)
{
Source = source;
Target = target;
Source.IsConnected = true;
Target.IsConnected = true;
}
public ConnectorViewModel Source { get; }
public ConnectorViewModel Target { get; }
}
```
And don't forget to bind it in the connector template.
```xml
IsConnected="{Binding IsConnected}"
```
### Materializing pending connections
The [PendingConnection](Connections-Overview#pending-connection) starts from a `Source` and will be completed when dropped on a `Target`. The source is _always_ a connector, and the target can be a [Connector](Connectors-Overview), an [ItemContainer](ItemContainer-Overview) or `null` otherwise. We will only care about other connectors for now. When the connection starts, the `StartedCommand` is executed which receives the `Source` as the parameter. When the connection completes, the `CompletedCommand` is executed which receives the `Target` as the parameter.
To create the commands we need an implementation of `ICommand`. I will use the following generic implementation:
```csharp
public class DelegateCommand<T> : ICommand
{
private readonly Action<T> _action;
private readonly Func<T, bool>? _condition;
public event EventHandler? CanExecuteChanged;
public DelegateCommand(Action<T> action, Func<T, bool>? executeCondition = default)
{
_action = action ?? throw new ArgumentNullException(nameof(action));
_condition = executeCondition;
}
public bool CanExecute(object? parameter)
{
if (parameter is T value)
{
return _condition?.Invoke(value) ?? true;
}
return _condition?.Invoke(default!) ?? true;
}
public void Execute(object? parameter)
{
if (parameter is T value)
{
_action(value);
}
else
{
_action(default!);
}
}
public void RaiseCanExecuteChanged()
=> CanExecuteChanged?.Invoke(this, new EventArgs());
}
```
Let's implement the pending connection view model and add it to the `EditorViewModel`.
```csharp
public class PendingConnectionViewModel
{
private readonly EditorViewModel _editor;
private ConnectorViewModel _source;
public PendingConnectionViewModel(EditorViewModel editor)
{
_editor = editor;
StartCommand = new DelegateCommand<ConnectorViewModel>(source => _source = source);
FinishCommand = new DelegateCommand<ConnectorViewModel>(target =>
{
if (target != null)
_editor.Connect(_source, target);
});
}
public ICommand StartCommand { get; }
public ICommand FinishCommand { get; }
}
public class EditorViewModel
{
public PendingConnectionViewModel PendingConnection { get; }
...
public EditorViewModel()
{
PendingConnection = new PendingConnectionViewModel(this);
...
}
...
public void Connect(ConnectorViewModel source, ConnectorViewModel target)
{
Connections.Add(new ConnectionViewModel(source, target));
}
}
```
And bind it to the view.
```xml
<nodify:NodifyEditor PendingConnection="{Binding PendingConnection}">
...
<nodify:NodifyEditor.PendingConnectionTemplate>
<DataTemplate DataType="{x:Type local:PendingConnectionViewModel}">
<nodify:PendingConnection StartedCommand="{Binding StartCommand}"
CompletedCommand="{Binding FinishCommand}"
AllowOnlyConnectors="True" />
</DataTemplate>
</nodify:NodifyEditor.PendingConnectionTemplate>
...
</nodify:NodifyEditor>
```
That's all. You should be able to create connections between connectors now.
### Removing connections
To remove connections you just have to listen for a disconnect event from the connector itself or from the editor and remove the connection that has the connector as the source or target. To keep it simple, we're gonna implement the `DisconnectConnectorCommand` for the `NodifyEditor`. Let's add it to the `EditorViewModel` first.
```csharp
public class EditorViewModel
{
public ICommand DisconnectConnectorCommand { get; }
...
public EditorViewModel()
{
DisconnectConnectorCommand = new DelegateCommand<ConnectorViewModel>(connector =>
{
var connection = Connections.First(x => x.Source == connector || x.Target == connector);
connection.Source.IsConnected = false; // This is not correct if there are multiple connections to the same connector
connection.Target.IsConnected = false;
Connections.Remove(connection);
});
...
}
}
```
Now we have to bind the command to the editor view.
```xml
<nodify:NodifyEditor ItemsSource="{Binding Nodes}"
Connections="{Binding Connections}"
PendingConnection="{Binding PendingConnection}"
DisconnectConnectorCommand="{Binding DisconnectConnectorCommand}">
...
</nodify:NodifyEditor>
```
### Controlling node location
As you can see, the nodes are always in the top left corner of the screen. That's because they are at location (0, 0) inside the graph. Let's change that!
Add a `Location` property of type `System.Windows.Point` in the `NodeViewModel` that raises PropertyChanged events.
```csharp
public class NodeViewModel : INotifyPropertyChanged
{
private Point _location;
public Point Location
{
set
{
_location = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Location)));
}
get => _location;
}
public event PropertyChangedEventHandler PropertyChanged;
...
}
```
And bind it to the view.
```xml
<nodify:NodifyEditor ItemsSource="{Binding Nodes}"
Connections="{Binding Connections}"
PendingConnection="{Binding PendingConnection}">
<nodify:NodifyEditor.ItemContainerStyle>
<Style TargetType="{x:Type nodify:ItemContainer}">
<Setter Property="Location"
Value="{Binding Location}" />
</Style>
</nodify:NodifyEditor.ItemContainerStyle>
...
</nodify:NodifyEditor>
```
> Note: I used the `ItemContainerStyle` to bind the location of the node. Please check out the [ItemContainer overview](ItemContainer-Overview) for more info.
Now you can set the location of the nodes when constructed.
## Drawing a grid
Drawing a simple grid is just a matter of creating a grid brush, applying the editor transform to it, and using the brush as the `Background` of the editor.
Because the grid we are drawing is made of lines and is not filled, the `Background` of the editor will have some transparency, meaning that we'll see the background color of the control below. To solve this, wrap the editor in a `Grid` and set its `Background` or set the `Background` of the `Window`.
Use the `ViewportTransform` dependency property to have the grid move with the view.
> Note: The example uses static resources which are provided by the selected theme in `App.xaml`.
```xml
<Window x:Class="MyProject.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:nodify="https://miroiu.github.io/nodify"
mc:Ignorable="d">
<Window.Resources>
<GeometryDrawing x:Key="SmallGridGeometry"
Geometry="M0,0 L0,1 0.03,1 0.03,0.03 1,0.03 1,0 Z"
Brush="{StaticResource NodifyEditor.SelectionRectangleBackgroundBrush}" />
<GeometryDrawing x:Key="LargeGridGeometry"
Geometry="M0,0 L0,1 0.015,1 0.015,0.015 1,0.015 1,0 Z"
Brush="{StaticResource NodifyEditor.SelectionRectangleBackgroundBrush}" />
<DrawingBrush x:Key="SmallGridLinesDrawingBrush"
TileMode="Tile"
ViewportUnits="Absolute"
Viewport="0 0 20 20"
Transform="{Binding ViewportTransform, ElementName=Editor}"
Drawing="{StaticResource SmallGridGeometry}" />
<DrawingBrush x:Key="LargeGridLinesDrawingBrush"
TileMode="Tile"
ViewportUnits="Absolute"
Opacity="0.5"
Viewport="0 0 100 100"
Transform="{Binding ViewportTransform, ElementName=Editor}"
Drawing="{StaticResource LargeGridGeometry}" />
</Window.Resources>
<Grid Background="{StaticResource NodifyEditor.BackgroundBrush}">
<nodify:NodifyEditor x:Name="Editor" Background="{StaticResource SmallGridLinesDrawingBrush}" />
<Grid Background="{StaticResource LargeGridLinesDrawingBrush}"
Panel.ZIndex="-2" />
</Grid>
</Window>
```
> Tip: Right-click and drag the screen around to move the view and use the mouse wheel to zoom in and out.

34
docs/Home.md Normal file
View File

@@ -0,0 +1,34 @@
![editor-interaction](https://user-images.githubusercontent.com/12727904/192004838-ec6dd997-5e64-4c01-940c-1cd1b8d27837.gif)
# Welcome to Nodify!
Nodify is a WPF node-based [editor control](Editor-Overview) featuring a collection of [nodes](Nodes-Overview), [connections](Connections-Overview), and [connectors](Connectors-Overview) components aiming to simplify the process of building node-based tools.
It is inspired by Unreal Engine's [Blueprints Visual Scripting](https://docs.unrealengine.com/en-US/ProgrammingAndScripting/Blueprints/index.html) system but focuses only on the user interface and user interaction part. Unlike Blueprints, Nodify is a general-purpose library that offers a node graph editor component that can be embedded in any WPF application.
The graph editor is an infinite area where you can place and move nodes around, select and drag groups of nodes, connect and disconnect nodes or connectors, zoom in and out, and automatically move the screen when dragging a node or a wire near the edges and much more.
Nodify is feature-rich and optimized for interaction with hundreds of nodes at once, and... it is built from the ground up to work with MVVM.
### Requirements
![IDE](https://img.shields.io/static/v1?label=%20&message=VS%202019%20or%20greater&color=informational&style=for-the-badge&logo=visual-studio)
![C#](https://img.shields.io/static/v1?label=%20&message=8.0&color=239120&style=for-the-badge&logo=c-sharp)
![.NET](https://img.shields.io/static/v1?label=%20&message=Framework%204.7.2%20to%20NET%206&color=5C2D91&style=for-the-badge&logo=.net)
### Install Nodify from Nuget
[![Download Package](https://img.shields.io/nuget/v/Nodify?label=Download&logo=nuget&style=for-the-badge)](https://www.nuget.org/packages/Nodify/)
```xml
Install-Package Nodify
```
### Application examples
- [Playground](https://github.com/miroiu/nodify/tree/master/Examples/Nodify.Playground)
- [Shapes](https://github.com/miroiu/nodify/tree/master/Examples/Nodify.Shapes)
- [State machine](https://github.com/miroiu/nodify/tree/master/Examples/Nodify.StateMachine)
- [Calculator](https://github.com/miroiu/nodify/tree/master/Examples/Nodify.Calculator)
[![IDE](https://img.shields.io/static/v1?label=%20&message=GET%20STARTED&color=9cf&style=for-the-badge)](Getting-Started)

View File

@@ -0,0 +1,53 @@
The ```ItemContainer``` is the **most important** piece of an editor. It is a content control that wraps every other control that is generated by the ```NodifyEditor```'s ```ItemsSource``` and has a `Location` in graph coordinates.
## Table of contents
- [Selecting](#selecting)
- [API](#selection-api)
- [Moving](#moving-and-dragging)
## Selecting
Selecting an ```ItemContainer``` is done by releasing the left mouse button over the bounding box of the container. The bounding box is calculated using the ```DesiredSizeForSelection``` dependency property if specified, otherwise using the ```RenderSize```.
> Note: A container can be selected programmatically by setting the ```IsSelected``` dependency property to ```true```.
The container will also be selected if the left mouse button is not released and the mouse is moved, which will clear the current selection and start a dragging operation on the selected container.
Selection can also be done by releasing the right mouse button on the container which will clear the current selection and select the target container.
Different behavior is used depending on the ```ModifierKeys``` held when selecting a container:
- ```Replace``` - no modifier key (default behavior, clears the selected items and selects the container)
- ```Append``` - shift key (adds the container to the selected items)
- ```Invert``` - control key (toggles the container's ```IsSelected``` dependency property)
An ```ItemContainer``` can only be selected if the ```IsSelectable``` dependency property is ```true```.
Selecting or unselecting a container will fire the ```Selected``` event, respectively the ```Unselected``` event, and will set the ```IsSelected``` dependency property to the new value.
If the default style is not overridden, the container's border will use the ```SelectedBrush``` dependency property.
Default values:
- ```IsSelectable```: true
- ```IsSelected```: false
### Selection API
* IsSelectableInArea
## Moving and dragging
A dragging operation can be started by holding the left mouse button on an ```ItemContainer``` and moving the mouse.
An ```ItemContainer``` can be dragged only if its ```IsDraggable``` dependency property is set to ```true```.
> Note: ```ItemContainer```s can be programmatically moved by setting their ```Location``` dependency property.
Dragging an ```ItemContainer``` fires a sequence of events that are handled by the ```NodifyEditor``` and applies to all the selected items:
- ```DragStarted``` - will set ```IsPreviewingLocation``` dependency property to ```true```;
- ```DragDelta``` - will be fired until the dragging operation is finished or canceled and will move all the selected items with it;
- ```DragCompleted``` - will finish or cancel the dragging operation and set the ```Location``` dependency property to the final position and ```IsPreviewingLocation``` to ```false```.
> Note: A dragging operation can be canceled by releasing the right mouse button if ```AllowDraggingCancellation``` is set to ```true```.
Default values:
- ```IsDraggable```: true
- ```AllowDraggingCancellation```: true

73
docs/Minimap-Overview.md Normal file
View File

@@ -0,0 +1,73 @@
## Table of contents
- [Moving the viewport](#panning)
- [Zooming](#zooming)
- [Customization](#customization)
The `Minimap` control is a custom control designed to provide a synchronized and miniature view of items in a `NodifyEditor`. It inherits from `ItemsControl` and displays items through the `ItemsSource` property. Each item is wrapped in a `MinimapItem` container that requires the `Location`, `Width`, and `Height` properties to be set in the `ItemContainerStyle`.
> [!TIP]
> For real-time movement of nodes inside the minimap, it's required to set `NodifyEditor.EnableDraggingContainersOptimizations` to `false`.
The control also displays a viewport rectangle that represents the visible area in the editor and requires the `ViewportLocation` and `ViewportSize` properties to be set.
```xml
<nodify:Minimap
ItemsSource="{Binding ItemsSource, ElementName=Editor}"
ViewportLocation="{Binding ViewportLocation, ElementName=Editor}"
ViewportSize="{Binding ViewportSize, ElementName=Editor}"
Zoom="OnMinimapZoom">
<nodify:Minimap.ItemContainerStyle>
<Style TargetType="nodify:MinimapItem">
<Setter Property="Location" Value="{Binding MyItemLocation}" />
</Style>
</nodify:Minimap.ItemContainerStyle>
</nodify:Minimap>
```
```csharp
private void OnMinimapZoom(object sender, ZoomEventArgs e)
{
Editor.ZoomAtPosition(e.Zoom, e.Location);
}
```
> [!IMPORTANT]
> The `Width` and `Height` should be constrained by the parent container or set to constant values on the `Minimap` to prevent resizing to fit the content.
## Panning
Panning is done by holding click and dragging and can be disabled by setting the `IsReadOnly` property to `true`. The `ViewportLocation` is updated during panning, therefore it must be a two-way binding (binds two ways by default).
The panning gesture can be configured by setting `EditorGestures.Mappings.Minimap.DragViewport` to the desired gesture.
## Zooming
Zooming is done by scrolling the mouse wheel and can be disabled by setting the `IsReadOnly` property to `true` or by not handling the `Zoom` event.
The zooming modifier key can be configured by setting `EditorGestures.Mappings.Minimap.ZoomModifierKey` to the desired value.
## Customization
The `ViewportStyle` is used to customize the viewport rectangle.
```xml
<Style x:Key="MyViewportStyle" TargetType="Rectangle">
<Setter Property="Fill" Value="Transparent"/>
<Setter Property="Stroke" Value="White"/>
<Setter Property="StrokeThickness" Value="3"/>
</Style>
<nodify:Minimap ViewportStyle="{StaticResource MyViewportStyle}" ... />
```
The `MaxViewportOffset` property is used to restrict how far the viewport can be moved away from the items when [panning](#panning).
The `ResizeToViewport` property changes the resizing behavior of the minimap.
If `true`, the minimap will resize to always display the viewport alongside the items.
![scale-with-viewport](https://github.com/user-attachments/assets/7a8887bf-f3f4-44d7-8311-6d9ba7869d78)
If `false`, the minimap will resize to only include the items, allowing the viewport to go out of bounds.
![viewport-out-of-bounds](https://github.com/user-attachments/assets/5d3b388e-8e40-4bfe-af3b-4c12fb47548d)

117
docs/Nodes-Overview.md Normal file
View File

@@ -0,0 +1,117 @@
Nodes are the building blocks of a node editor. They are wrapped in [`ItemContainer`s](ItemContainer-Overview) and can be any custom control. (e.g. a TextBlock)
The following nodes are part of the library:
### 1. The ```Node``` control
This type of node supports both ```Input``` and ```Output``` connectors and can be moved around.
```xml
<nodify:NodifyEditor xmlns:sys="clr-namespace:System;assembly=mscorlib">
<nodify:NodifyEditor.ItemsSource>
<CompositeCollection>
<nodify:Node Header="My Node">
<nodify:Node.Input>
<CompositeCollection>
<sys:String>In 0</sys:String>
<sys:String>In 1</sys:String>
</CompositeCollection>
</nodify:Node.Input>
<nodify:Node.Output>
<CompositeCollection>
<sys:String>Out 0</sys:String>
<sys:String>Out 1</sys:String>
</CompositeCollection>
</nodify:Node.Output>
<nodify:Node.InputConnectorTemplate>
<DataTemplate>
<nodify:NodeInput Header="{Binding}" />
</DataTemplate>
</nodify:Node.InputConnectorTemplate>
<nodify:Node.OutputConnectorTemplate>
<DataTemplate>
<nodify:NodeOutput Header="{Binding}" />
</DataTemplate>
</nodify:Node.OutputConnectorTemplate>
</nodify:Node>
</CompositeCollection>
</nodify:NodifyEditor.ItemsSource>
</nodify:NodifyEditor>
```
The `Header` of the node can be customized using the `HeaderTemplate`. Respectively, the `Footer` of the node can be customized using the `FooterTemplate`.
Each item in the `Input` collection can be customized using the `InputConnectorTemplate`. Respectively the `Output` can be customized using the `OutputConnectorTemplate`.
![Node](https://i.imgur.com/VwAYlX3.gif)
### 2. The ```GroupingNode``` control
This type of node can be resized and will move nodes that are inside it if dragged by the ```Header```.
If the ```SwitchMovementModeModifierKey``` (**Shift** key by default) is held, it will move without moving its children.
```xml
<nodify:NodifyEditor>
<nodify:NodifyEditor.ItemsSource>
<CompositeCollection>
<nodify:GroupingNode Header="Grouping node"
Width="300"
Height="250" />
<nodify:Node Header="My node" />
<nodify:Node Header="My other node" />
</CompositeCollection>
</nodify:NodifyEditor.ItemsSource>
</nodify:NodifyEditor>
```
The `Header` of the node can be customized using the `HeaderTemplate`. Respectively the `Content` of the node can be customized using the `ContentTemplate`.
The size of the node can be set programmatically by changing the `ActualSize` dependency property value.
#### Default values
* CanResize: true
* MovementMode: Grouped
#### Commands
* ResizeCompleted
* ResizeStarted
![Grouping Node](https://i.imgur.com/HYxt2cs.gif)
### 3. The ```KnotNode``` control
This type of control can be used to reroute ```Connection```s as it supports only one ```Connector```.
The `Content` of the node can be customized using the `ContentTemplate`.
```xml
<nodify:NodifyEditor>
<nodify:NodifyEditor.ItemsSource>
<CompositeCollection>
<nodify:KnotNode />
</CompositeCollection>
</nodify:NodifyEditor.ItemsSource>
</nodify:NodifyEditor>
```
![Knot Node](https://i.imgur.com/fMrEqY1.gif)
### 4. The ```StateNode``` control
This type of node is a ```Connector``` itself, meaning that it will raise ```PendingConnection``` events on interaction. Because it inherits from `Connector`, you need to bind the `Anchor` property and `IsConnected` to the corresponding state. (if IsConnected is set to false, the connections won't update)
```xml
<nodify:NodifyEditor>
<nodify:NodifyEditor.ItemsSource>
<CompositeCollection>
<nodify:StateNode Content="My node" />
</CompositeCollection>
</nodify:NodifyEditor.ItemsSource>
</nodify:NodifyEditor>
```
The `Content` of the node can be customized using the `ContentTemplate`.
![State Node](https://i.imgur.com/FrI2epL.gif)

66
docs/_Sidebar.md Normal file
View File

@@ -0,0 +1,66 @@
| [English](https://github.com/miroiu/nodify/wiki/Home) | [简体中文](https://github.com/miroiu/nodify/wiki/主页) |
| ----------------------------------------------------- | ------------------------------------------------------ |
---
## [Home](Home)
[Getting Started](Getting-Started)
- [Hierarchy and terminology](Getting-Started#hierarchy-and-terminology)
- [Content layers](Getting-Started#content-layers)
- [Creating an editor](Getting-Started#creating-an-editor)
- [Using a theme](Getting-Started#using-an-existing-theme)
- [Minimal example](Getting-Started#a-minimal-example)
- [Drawing a grid](Getting-Started#drawing-a-grid)
[Editor overview](Editor-Overview)
- [Moving the viewport](Editor-Overview#panning)
- [Zooming](Editor-Overview#zooming)
- [Scrolling](Editor-Overview#scrolling)
- [Selecting items](Editor-Overview#selecting)
- [Pushing items](Editor-Overview#pushing-items)
- [Snapping to grid](Editor-Overview#snapping)
- [Commands](Editor-Overview#commands)
[ItemContainer overview](ItemContainer-Overview)
- [Selecting](ItemContainer-Overview#selecting)
- [Moving](ItemContainer-Overview#moving-and-dragging)
[Nodes overview](Nodes-Overview)
- [The node](Nodes-Overview#1-the-node-control)
- [The grouping node](Nodes-Overview#2-the-groupingnode-control)
- [The knot node](Nodes-Overview#3-the-knotnode-control)
- [The state node](Nodes-Overview#4-the-statenode-control)
[Connections overview](Connections-Overview)
- [Base connection](Connections-Overview#base-connection)
- [Bezier connection](Connections-Overview#connection)
- [Line connection](Connections-Overview#line-connection)
- [Circuit connection](Connections-Overview#circuit-connection)
- [Step connection](Connections-Overview#step-connection)
- [Pending connection](Connections-Overview#pending-connection)
[Connectors overview](Connectors-Overview)
- [NodeInput and NodeOutput](Connectors-Overview#nodeinput-and-nodeoutput)
[CuttingLine overview](CuttingLine-Overview)
- [Enabling preview](CuttingLine-Overview#enabling-preview)
- [Custom connections](CuttingLine-Overview#custom-connections)
- [Customization](CuttingLine-Overview#customization)
[Minimap overview](Minimap-Overview)
- [Moving the viewport](Minimap-Overview#panning)
- [Zooming](Minimap-Overview#zooming)
- [Customization](Minimap-Overview#customization)
[API Reference](API-Reference)
[(FAQ) Frequently asked questions](FAQ)

114
docs/api/API-Reference.md Normal file
View File

@@ -0,0 +1,114 @@
## Nodify
- [Alignment Enum](Nodify_Alignment)
- [ArrowHeadEnds Enum](Nodify_ArrowHeadEnds)
- [ArrowHeadShape Enum](Nodify_ArrowHeadShape)
- [BaseConnection Class](Nodify_BaseConnection)
- [BoxValue Class](Nodify_BoxValue)
- [CircuitConnection Class](Nodify_CircuitConnection)
- [Connection Class](Nodify_Connection)
- [ConnectionContainer Class](Nodify_ConnectionContainer)
- [ConnectionDirection Enum](Nodify_ConnectionDirection)
- [ConnectionOffsetMode Enum](Nodify_ConnectionOffsetMode)
- [ConnectionsMultiSelector Class](Nodify_ConnectionsMultiSelector)
- [Connector Class](Nodify_Connector)
- [ConnectorPosition Enum](Nodify_ConnectorPosition)
- [CuttingLine Class](Nodify_CuttingLine)
- [DecoratorContainer Class](Nodify_DecoratorContainer)
- [DecoratorsControl Class](Nodify_DecoratorsControl)
- [EditorCommands Class](Nodify_EditorCommands)
- [GroupingMovementMode Enum](Nodify_GroupingMovementMode)
- [GroupingNode Class](Nodify_GroupingNode)
- [HotKeyControl Class](Nodify_HotKeyControl)
- [HotKeysDisplayMode Enum](Nodify_HotKeysDisplayMode)
- [INodifyCanvasItem Interface](Nodify_INodifyCanvasItem)
- [ItemContainer Class](Nodify_ItemContainer)
- [KnotNode Class](Nodify_KnotNode)
- [LineConnection Class](Nodify_LineConnection)
- [Minimap Class](Nodify_Minimap)
- [MinimapItem Class](Nodify_MinimapItem)
- [Node Class](Nodify_Node)
- [NodeInput Class](Nodify_NodeInput)
- [NodeOutput Class](Nodify_NodeOutput)
- [NodifyCanvas Class](Nodify_NodifyCanvas)
- [NodifyEditor Class](Nodify_NodifyEditor)
- [PendingConnection Class](Nodify_PendingConnection)
- [SelectionType Enum](Nodify_SelectionType)
- [StateNode Class](Nodify_StateNode)
- [StepConnection Class](Nodify_StepConnection)
## Nodify.Events
- [ConnectionEventArgs Class](Nodify_Events_ConnectionEventArgs)
- [ConnectionEventHandler Delegate](Nodify_Events_ConnectionEventHandler)
- [ConnectorEventArgs Class](Nodify_Events_ConnectorEventArgs)
- [ConnectorEventHandler Delegate](Nodify_Events_ConnectorEventHandler)
- [ItemsMovedEventArgs Class](Nodify_Events_ItemsMovedEventArgs)
- [ItemsMovedEventHandler Delegate](Nodify_Events_ItemsMovedEventHandler)
- [PendingConnectionEventArgs Class](Nodify_Events_PendingConnectionEventArgs)
- [PendingConnectionEventHandler Delegate](Nodify_Events_PendingConnectionEventHandler)
- [PreviewLocationChanged Delegate](Nodify_Events_PreviewLocationChanged)
- [ResizeEventArgs Class](Nodify_Events_ResizeEventArgs)
- [ResizeEventHandler Delegate](Nodify_Events_ResizeEventHandler)
- [ZoomEventArgs Class](Nodify_Events_ZoomEventArgs)
- [ZoomEventHandler Delegate](Nodify_Events_ZoomEventHandler)
## Nodify.Interactivity
- [AllGestures Class](Nodify_Interactivity_AllGestures)
- [AnyGesture Class](Nodify_Interactivity_AnyGesture)
- [ConnectionState Class](Nodify_Interactivity_ConnectionState)
- [Disconnect Class](Nodify_Interactivity_ConnectionState_Disconnect)
- [Split Class](Nodify_Interactivity_ConnectionState_Split)
- [ConnectorState Class](Nodify_Interactivity_ConnectorState)
- [Connecting Class](Nodify_Interactivity_ConnectorState_Connecting)
- [Default Class](Nodify_Interactivity_ConnectorState_Default)
- [Disconnect Class](Nodify_Interactivity_ConnectorState_Disconnect)
- [ContainerState Class](Nodify_Interactivity_ContainerState)
- [Default Class](Nodify_Interactivity_ContainerState_Default)
- [DragState\<TElement\> Class](Nodify_Interactivity_DragState_TElement_)
- [EditorGestures Class](Nodify_Interactivity_EditorGestures)
- [ConnectionGestures Class](Nodify_Interactivity_EditorGestures_ConnectionGestures)
- [ConnectorGestures Class](Nodify_Interactivity_EditorGestures_ConnectorGestures)
- [DirectionalNavigationGestures Class](Nodify_Interactivity_EditorGestures_DirectionalNavigationGestures)
- [GroupingNodeGestures Class](Nodify_Interactivity_EditorGestures_GroupingNodeGestures)
- [ItemContainerGestures Class](Nodify_Interactivity_EditorGestures_ItemContainerGestures)
- [MinimapGestures Class](Nodify_Interactivity_EditorGestures_MinimapGestures)
- [NodifyEditorGestures Class](Nodify_Interactivity_EditorGestures_NodifyEditorGestures)
- [SelectionGestures Class](Nodify_Interactivity_EditorGestures_SelectionGestures)
- [EditorState Class](Nodify_Interactivity_EditorState)
- [Cutting Class](Nodify_Interactivity_EditorState_Cutting)
- [KeyboardNavigation Class](Nodify_Interactivity_EditorState_KeyboardNavigation)
- [Panning Class](Nodify_Interactivity_EditorState_Panning)
- [PanningWithMouseWheel Class](Nodify_Interactivity_EditorState_PanningWithMouseWheel)
- [PushingItems Class](Nodify_Interactivity_EditorState_PushingItems)
- [Selecting Class](Nodify_Interactivity_EditorState_Selecting)
- [Zooming Class](Nodify_Interactivity_EditorState_Zooming)
- [IInputHandler Interface](Nodify_Interactivity_IInputHandler)
- [IKeyboardFocusTarget\<TElement\> Interface](Nodify_Interactivity_IKeyboardFocusTarget_TElement_)
- [IKeyboardNavigationLayer Interface](Nodify_Interactivity_IKeyboardNavigationLayer)
- [IKeyboardNavigationLayerGroup Interface](Nodify_Interactivity_IKeyboardNavigationLayerGroup)
- [InputElementState\<TElement\> Class](Nodify_Interactivity_InputElementState_TElement_)
- [InputElementStateStack\<TElement\> Class](Nodify_Interactivity_InputElementStateStack_TElement_)
- [DragState\<TElement\> Class](Nodify_Interactivity_InputElementStateStack_TElement__DragState_TElement_)
- [IInputElementState\<TElement\> Interface](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_)
- [InputElementState\<TElement\> Class](Nodify_Interactivity_InputElementStateStack_TElement__InputElementState_TElement_)
- [InputGestureRef Class](Nodify_Interactivity_InputGestureRef)
- [InputGestureRefExtensions Class](Nodify_Interactivity_InputGestureRefExtensions)
- [InputProcessor Class](Nodify_Interactivity_InputProcessor)
- [Shared\<TElement\> Class](Nodify_Interactivity_InputProcessor_Shared_TElement_)
- [InputProcessorExtensions Class](Nodify_Interactivity_InputProcessorExtensions)
- [KeyboardNavigationLayerId Class](Nodify_Interactivity_KeyboardNavigationLayerId)
- [KeyComboGesture Class](Nodify_Interactivity_KeyComboGesture)
- [MinimapState Class](Nodify_Interactivity_MinimapState)
- [KeyboardNavigation Class](Nodify_Interactivity_MinimapState_KeyboardNavigation)
- [Panning Class](Nodify_Interactivity_MinimapState_Panning)
- [Zooming Class](Nodify_Interactivity_MinimapState_Zooming)
- [MouseGesture Class](Nodify_Interactivity_MouseGesture)
- [MultiGesture Class](Nodify_Interactivity_MultiGesture)
- [Match Enum](Nodify_Interactivity_MultiGesture_Match)
- [NodifyEditorGestures.KeyboardGestures Class](Nodify_Interactivity_NodifyEditorGestures_KeyboardGestures)

View File

@@ -0,0 +1,52 @@
# Alignment Enum
**Namespace:** Nodify
**Assembly:** Nodify
**References:** [EditorCommands](Nodify_EditorCommands), [NodifyEditor](Nodify_NodifyEditor)
Specifies the possible alignment values used by the NodifyEditor.AlignSelection(Alignment) method.
```csharp
public enum Alignment
```
## Fields
### Bottom
```csharp
Bottom = 2;
```
### Center
```csharp
Center = 5;
```
### Left
```csharp
Left = 1;
```
### Middle
```csharp
Middle = 4;
```
### Right
```csharp
Right = 3;
```
### Top
```csharp
Top = 0;
```

View File

@@ -0,0 +1,48 @@
# ArrowHeadEnds Enum
**Namespace:** Nodify
**Assembly:** Nodify
**References:** [BaseConnection](Nodify_BaseConnection)
The end at which the arrow head is drawn.
```csharp
public enum ArrowHeadEnds
```
## Fields
### Both
Arrow heads at both ends.
```csharp
Both = 2;
```
### End
Arrow head at end.
```csharp
End = 1;
```
### None
No arrow head.
```csharp
None = 3;
```
### Start
Arrow head at start.
```csharp
Start = 0;
```

View File

@@ -0,0 +1,40 @@
# ArrowHeadShape Enum
**Namespace:** Nodify
**Assembly:** Nodify
**References:** [BaseConnection](Nodify_BaseConnection)
The shape of the arrowhead.
```csharp
public enum ArrowHeadShape
```
## Fields
### Arrowhead
The default arrowhead.
```csharp
Arrowhead = 0;
```
### Ellipse
An ellipse.
```csharp
Ellipse = 1;
```
### Rectangle
A rectangle.
```csharp
Rectangle = 2;
```

View File

@@ -0,0 +1,805 @@
# BaseConnection Class
**Namespace:** Nodify
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [DispatcherObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Threading.DispatcherObject) → [DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject) → [Visual](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Visual) → [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement) → [FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement) → [Shape](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Shapes.Shape) → [BaseConnection](Nodify_BaseConnection)
**Implements:** [IKeyboardFocusTarget\<FrameworkElement\>](Nodify_Interactivity_IKeyboardFocusTarget_TElement_)
**Derived:** [LineConnection](Nodify_LineConnection), [Connection](Nodify_Connection)
**References:** [ArrowHeadEnds](Nodify_ArrowHeadEnds), [ArrowHeadShape](Nodify_ArrowHeadShape), [ConnectionDirection](Nodify_ConnectionDirection), [ConnectionEventArgs](Nodify_Events_ConnectionEventArgs), [ConnectionEventHandler](Nodify_Events_ConnectionEventHandler), [ConnectionOffsetMode](Nodify_ConnectionOffsetMode), [CuttingLine](Nodify_CuttingLine), [ConnectionState.Disconnect](Nodify_Interactivity_ConnectionState_Disconnect), [NodifyEditor](Nodify_NodifyEditor), [ConnectionState.Split](Nodify_Interactivity_ConnectionState_Split)
Represents the base class for shapes that are drawn from a [BaseConnection.Source](Nodify_BaseConnection#source) point to a [BaseConnection.Target](Nodify_BaseConnection#target) point.
```csharp
public abstract class BaseConnection : Shape, IKeyboardFocusTarget<FrameworkElement>
```
## Constructors
### BaseConnection()
```csharp
protected BaseConnection();
```
## Fields
### ZeroVector
Gets a vector that has its coordinates set to 0.
```csharp
protected static Vector ZeroVector;
```
**Field Value**
[Vector](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Vector)
## Properties
### ArrowEnds
Gets or sets the arrowhead ends.
```csharp
public ArrowHeadEnds ArrowEnds { get; set; }
```
**Property Value**
[ArrowHeadEnds](Nodify_ArrowHeadEnds)
### ArrowShape
Gets or sets the arrowhead ends.
```csharp
public ArrowHeadShape ArrowShape { get; set; }
```
**Property Value**
[ArrowHeadShape](Nodify_ArrowHeadShape)
### ArrowSize
Gets or sets the size of the arrow head.
```csharp
public Size ArrowSize { get; set; }
```
**Property Value**
[Size](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Size)
### DefiningGeometry
```csharp
protected override Geometry DefiningGeometry { get; set; }
```
**Property Value**
[Geometry](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Geometry)
### Direction
Gets or sets the direction in which this connection is flowing.
```csharp
public ConnectionDirection Direction { get; set; }
```
**Property Value**
[ConnectionDirection](Nodify_ConnectionDirection)
### DirectionalArrowsAnimationDuration
Gets or sets the duration in seconds of a directional arrow flowing from [BaseConnection.Source](Nodify_BaseConnection#source) to [BaseConnection.Target](Nodify_BaseConnection#target).
```csharp
public double DirectionalArrowsAnimationDuration { get; set; }
```
**Property Value**
[Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double)
### DirectionalArrowsCount
Gets or sets the number of arrows to be drawn on the line in the direction of the connection (see [BaseConnection.Direction](Nodify_BaseConnection#direction)).
```csharp
public uint DirectionalArrowsCount { get; set; }
```
**Property Value**
[UInt32](https://docs.microsoft.com/en-us/dotnet/api/System.UInt32)
### DirectionalArrowsOffset
Gets or sets the offset of the arrows drawn by the [BaseConnection.DirectionalArrowsCount](Nodify_BaseConnection#directionalarrowscount) (value is clamped between 0 and 1).
```csharp
public double DirectionalArrowsOffset { get; set; }
```
**Property Value**
[Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double)
### DisconnectCommand
Removes this connection. Triggered by Nodify.Interactivity.EditorGestures.ConnectionGestures.Disconnect gesture.
Parameter is the location where the disconnect ocurred.
```csharp
public ICommand DisconnectCommand { get; set; }
```
**Property Value**
[ICommand](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ICommand)
### FocusVisualPadding
The space between the focus visual and the connection geometry.
```csharp
public double FocusVisualPadding { get; set; }
```
**Property Value**
[Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double)
### FocusVisualPen
The pen used to render the focus visual.
```csharp
public Pen FocusVisualPen { get; set; }
```
**Property Value**
[Pen](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Pen)
### FocusVisualPenKey
The key used to retrieve the [BaseConnection.FocusVisualPen](Nodify_BaseConnection#focusvisualpen) resource.
```csharp
public static ResourceKey FocusVisualPenKey { get; set; }
```
**Property Value**
[ResourceKey](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.ResourceKey)
### FontFamily
```csharp
public FontFamily FontFamily { get; set; }
```
**Property Value**
[FontFamily](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.FontFamily)
### FontSize
```csharp
public double FontSize { get; set; }
```
**Property Value**
[Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double)
### FontStretch
```csharp
public FontStretch FontStretch { get; set; }
```
**Property Value**
[FontStretch](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FontStretch)
### FontStyle
```csharp
public FontStyle FontStyle { get; set; }
```
**Property Value**
[FontStyle](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FontStyle)
### FontWeight
```csharp
public FontWeight FontWeight { get; set; }
```
**Property Value**
[FontWeight](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FontWeight)
### Foreground
The brush used to render the [BaseConnection.Text](Nodify_BaseConnection#text).
```csharp
public Brush Foreground { get; set; }
```
**Property Value**
[Brush](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Brush)
### HasContextMenu
Gets a value indicating whether the connection has a context menu.
```csharp
public bool HasContextMenu { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### HasCustomContextMenu
Gets or sets a value indicating whether the connection uses a custom context menu.
```csharp
public bool HasCustomContextMenu { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### IsAnimatingDirectionalArrows
Gets or sets whether the directional arrows should be flowing through the connection wire.
```csharp
public bool IsAnimatingDirectionalArrows { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### OutlineBrush
The brush used to render the outline.
```csharp
public Brush OutlineBrush { get; set; }
```
**Property Value**
[Brush](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Brush)
### OutlineThickness
The thickness of the outline.
```csharp
public double OutlineThickness { get; set; }
```
**Property Value**
[Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double)
### PrioritizeBaseConnectionForSelection
Whether to prioritize controls of type [BaseConnection](Nodify_BaseConnection) inside custom connections (connection wrappers)
when setting the [BaseConnection.IsSelectableProperty](Nodify_BaseConnection#isselectableproperty) and [BaseConnection.IsSelectedProperty](Nodify_BaseConnection#isselectedproperty) attached properties.
```csharp
public static bool PrioritizeBaseConnectionForSelection { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### Source
Gets or sets the start point of this connection.
```csharp
public Point Source { get; set; }
```
**Property Value**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### SourceOffset
Gets or sets the offset from the [BaseConnection.Source](Nodify_BaseConnection#source) point.
```csharp
public Size SourceOffset { get; set; }
```
**Property Value**
[Size](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Size)
### SourceOffsetMode
Gets or sets the [ConnectionOffsetMode](Nodify_ConnectionOffsetMode) to apply to the [BaseConnection.Source](Nodify_BaseConnection#source) when drawing the connection.
```csharp
public ConnectionOffsetMode SourceOffsetMode { get; set; }
```
**Property Value**
[ConnectionOffsetMode](Nodify_ConnectionOffsetMode)
### SourceOrientation
Gets or sets the orientation in which this connection is flowing.
```csharp
public Orientation SourceOrientation { get; set; }
```
**Property Value**
[Orientation](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.Orientation)
### Spacing
The distance between the start point and the where the angle breaks.
```csharp
public double Spacing { get; set; }
```
**Property Value**
[Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double)
### SplitCommand
Splits the connection. Triggered by Nodify.Interactivity.EditorGestures.ConnectionGestures.Split gesture.
Parameter is the location where the splitting ocurred.
```csharp
public ICommand SplitCommand { get; set; }
```
**Property Value**
[ICommand](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ICommand)
### Target
Gets or sets the end point of this connection.
```csharp
public Point Target { get; set; }
```
**Property Value**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### TargetOffset
Gets or sets the offset from the [BaseConnection.Target](Nodify_BaseConnection#target) point.
```csharp
public Size TargetOffset { get; set; }
```
**Property Value**
[Size](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Size)
### TargetOffsetMode
Gets or sets the [ConnectionOffsetMode](Nodify_ConnectionOffsetMode) to apply to the [BaseConnection.Target](Nodify_BaseConnection#target) when drawing the connection.
```csharp
public ConnectionOffsetMode TargetOffsetMode { get; set; }
```
**Property Value**
[ConnectionOffsetMode](Nodify_ConnectionOffsetMode)
### TargetOrientation
Gets or sets the orientation in which this connection is flowing.
```csharp
public Orientation TargetOrientation { get; set; }
```
**Property Value**
[Orientation](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.Orientation)
### Text
Gets or sets the text contents of the [BaseConnection](Nodify_BaseConnection).
```csharp
public string Text { get; set; }
```
**Property Value**
[String](https://docs.microsoft.com/en-us/dotnet/api/System.String)
## Methods
### DrawArrowGeometry(StreamGeometryContext, Point, Point, ConnectionDirection, ArrowHeadShape, Orientation)
```csharp
protected virtual void DrawArrowGeometry(StreamGeometryContext context, Point source, Point target, ConnectionDirection arrowDirection = 0, ArrowHeadShape shape = 0, Orientation orientation = 0);
```
**Parameters**
`context` [StreamGeometryContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.StreamGeometryContext)
`source` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`target` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`arrowDirection` [ConnectionDirection](Nodify_ConnectionDirection)
`shape` [ArrowHeadShape](Nodify_ArrowHeadShape)
`orientation` [Orientation](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.Orientation)
### DrawDefaultArrowhead(StreamGeometryContext, Point, Point, ConnectionDirection, Orientation)
```csharp
protected virtual void DrawDefaultArrowhead(StreamGeometryContext context, Point source, Point target, ConnectionDirection arrowDirection = 0, Orientation orientation = 0);
```
**Parameters**
`context` [StreamGeometryContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.StreamGeometryContext)
`source` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`target` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`arrowDirection` [ConnectionDirection](Nodify_ConnectionDirection)
`orientation` [Orientation](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.Orientation)
### DrawDirectionalArrowheadGeometry(StreamGeometryContext, Vector, Point)
```csharp
protected virtual void DrawDirectionalArrowheadGeometry(StreamGeometryContext context, Vector direction, Point location);
```
**Parameters**
`context` [StreamGeometryContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.StreamGeometryContext)
`direction` [Vector](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Vector)
`location` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### DrawDirectionalArrowsGeometry(StreamGeometryContext, Point, Point)
```csharp
protected virtual void DrawDirectionalArrowsGeometry(StreamGeometryContext context, Point source, Point target);
```
**Parameters**
`context` [StreamGeometryContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.StreamGeometryContext)
`source` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`target` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### DrawEllipseArrowhead(StreamGeometryContext, Point, Point, ConnectionDirection, Orientation)
```csharp
protected virtual void DrawEllipseArrowhead(StreamGeometryContext context, Point source, Point target, ConnectionDirection arrowDirection = 0, Orientation orientation = 0);
```
**Parameters**
`context` [StreamGeometryContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.StreamGeometryContext)
`source` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`target` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`arrowDirection` [ConnectionDirection](Nodify_ConnectionDirection)
`orientation` [Orientation](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.Orientation)
### DrawLineGeometry(StreamGeometryContext, Point, Point)
```csharp
protected virtual ValueTuple<ValueTuple<Point, Point>, ValueTuple<Point, Point>> DrawLineGeometry(StreamGeometryContext context, Point source, Point target);
```
**Parameters**
`context` [StreamGeometryContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.StreamGeometryContext)
`source` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`target` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
**Returns**
[ValueTuple\<ValueTuple\<Point, Point\>, ValueTuple\<Point, Point\>\>](https://docs.microsoft.com/en-us/dotnet/api/System.ValueTuple-2)
### DrawRectangleArrowhead(StreamGeometryContext, Point, Point, ConnectionDirection, Orientation)
```csharp
protected virtual void DrawRectangleArrowhead(StreamGeometryContext context, Point source, Point target, ConnectionDirection arrowDirection = 0, Orientation orientation = 0);
```
**Parameters**
`context` [StreamGeometryContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.StreamGeometryContext)
`source` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`target` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`arrowDirection` [ConnectionDirection](Nodify_ConnectionDirection)
`orientation` [Orientation](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.Orientation)
### GetIsSelectable(UIElement)
```csharp
public static bool GetIsSelectable(UIElement elem);
```
**Parameters**
`elem` [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### GetIsSelected(UIElement)
```csharp
public static bool GetIsSelected(UIElement elem);
```
**Parameters**
`elem` [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### GetOffset()
Gets the resulting offset after applying the [BaseConnection.SourceOffsetMode](Nodify_BaseConnection#sourceoffsetmode).
```csharp
protected virtual ValueTuple<Vector, Vector> GetOffset();
```
**Returns**
[ValueTuple\<Vector, Vector\>](https://docs.microsoft.com/en-us/dotnet/api/System.ValueTuple-2)
### GetTextPosition(FormattedText, Point, Point)
```csharp
protected virtual Point GetTextPosition(FormattedText text, Point source, Point target);
```
**Parameters**
`text` [FormattedText](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.FormattedText)
`source` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`target` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
**Returns**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### OnKeyDown(KeyEventArgs)
```csharp
protected override void OnKeyDown(KeyEventArgs e);
```
**Parameters**
`e` [KeyEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.KeyEventArgs)
### OnKeyUp(KeyEventArgs)
```csharp
protected override void OnKeyUp(KeyEventArgs e);
```
**Parameters**
`e` [KeyEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.KeyEventArgs)
### OnLostMouseCapture(MouseEventArgs)
```csharp
protected override void OnLostMouseCapture(MouseEventArgs e);
```
**Parameters**
`e` [MouseEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseEventArgs)
### OnMouseDown(MouseButtonEventArgs)
```csharp
protected override void OnMouseDown(MouseButtonEventArgs e);
```
**Parameters**
`e` [MouseButtonEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseButtonEventArgs)
### OnMouseMove(MouseEventArgs)
```csharp
protected override void OnMouseMove(MouseEventArgs e);
```
**Parameters**
`e` [MouseEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseEventArgs)
### OnMouseUp(MouseButtonEventArgs)
```csharp
protected override void OnMouseUp(MouseButtonEventArgs e);
```
**Parameters**
`e` [MouseButtonEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseButtonEventArgs)
### OnMouseWheel(MouseWheelEventArgs)
```csharp
protected override void OnMouseWheel(MouseWheelEventArgs e);
```
**Parameters**
`e` [MouseWheelEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseWheelEventArgs)
### OnRender(DrawingContext)
```csharp
protected override void OnRender(DrawingContext drawingContext);
```
**Parameters**
`drawingContext` [DrawingContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.DrawingContext)
### Remove()
Removes the connection.
```csharp
public void Remove();
```
### SetIsSelectable(UIElement, Boolean)
```csharp
public static void SetIsSelectable(UIElement elem, bool value);
```
**Parameters**
`elem` [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement)
`value` [Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### SetIsSelected(UIElement, Boolean)
```csharp
public static void SetIsSelected(UIElement elem, bool value);
```
**Parameters**
`elem` [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement)
`value` [Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### SplitAtLocation(Point)
Splits the connection at the specified location.
```csharp
public void SplitAtLocation(Point splitLocation);
```
**Parameters**
`splitLocation` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point): The [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point) where the connection should be split.
### StartAnimation(Double)
Starts animating the directional arrows.
```csharp
public void StartAnimation(double duration = 1.5d);
```
**Parameters**
`duration` [Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double): The duration for moving an arrowhead from [BaseConnection.Source](Nodify_BaseConnection#source) to [BaseConnection.Target](Nodify_BaseConnection#target).
### StopAnimation()
Stops the animation started by Nodify.BaseConnection.StartAnimation(System.Double)
```csharp
public void StopAnimation();
```
## Events
### Disconnect
Triggered by the Nodify.Interactivity.EditorGestures.ConnectionGestures.Disconnect gesture.
```csharp
public event ConnectionEventHandler Disconnect;
```
**Event Type**
[ConnectionEventHandler](Nodify_Events_ConnectionEventHandler)
### Split
Triggered by the Nodify.Interactivity.EditorGestures.ConnectionGestures.Split gesture.
```csharp
public event ConnectionEventHandler Split;
```
**Event Type**
[ConnectionEventHandler](Nodify_Events_ConnectionEventHandler)

204
docs/api/Nodify_BoxValue.md Normal file
View File

@@ -0,0 +1,204 @@
# BoxValue Class
**Namespace:** Nodify
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [BoxValue](Nodify_BoxValue)
```csharp
public static class BoxValue
```
## Fields
### ArrowSize
```csharp
public static object ArrowSize;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### ConnectionOffset
```csharp
public static object ConnectionOffset;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### Double0
```csharp
public static object Double0;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### Double1
```csharp
public static object Double1;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### Double1000
```csharp
public static object Double1000;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### Double2
```csharp
public static object Double2;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### Double45
```csharp
public static object Double45;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### Double5
```csharp
public static object Double5;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### DoubleHalf
```csharp
public static object DoubleHalf;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### False
```csharp
public static object False;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### Int0
```csharp
public static object Int0;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### Int1
```csharp
public static object Int1;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### Point
```csharp
public static object Point;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### Rect
```csharp
public static object Rect;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### Size
```csharp
public static object Size;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### Thickness2
```csharp
public static object Thickness2;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### True
```csharp
public static object True;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### UInt0
```csharp
public static object UInt0;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### UInt1
```csharp
public static object UInt1;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)

View File

@@ -0,0 +1,100 @@
# CircuitConnection Class
**Namespace:** Nodify
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [DispatcherObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Threading.DispatcherObject) → [DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject) → [Visual](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Visual) → [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement) → [FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement) → [Shape](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Shapes.Shape) → [BaseConnection](Nodify_BaseConnection) → [LineConnection](Nodify_LineConnection) → [CircuitConnection](Nodify_CircuitConnection)
Represents a line that is controlled by an angle.
```csharp
public class CircuitConnection : LineConnection
```
## Constructors
### CircuitConnection()
```csharp
public CircuitConnection();
```
## Fields
### Degrees
```csharp
protected const double Degrees = 0.017453292519943295d;
```
**Field Value**
[Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double)
## Properties
### Angle
The angle of the connection in degrees.
```csharp
public double Angle { get; set; }
```
**Property Value**
[Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double)
## Methods
### DrawDirectionalArrowsGeometry(StreamGeometryContext, Point, Point)
```csharp
protected override void DrawDirectionalArrowsGeometry(StreamGeometryContext context, Point source, Point target);
```
**Parameters**
`context` [StreamGeometryContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.StreamGeometryContext)
`source` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`target` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### DrawLineGeometry(StreamGeometryContext, Point, Point)
```csharp
protected override ValueTuple<ValueTuple<Point, Point>, ValueTuple<Point, Point>> DrawLineGeometry(StreamGeometryContext context, Point source, Point target);
```
**Parameters**
`context` [StreamGeometryContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.StreamGeometryContext)
`source` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`target` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
**Returns**
[ValueTuple\<ValueTuple\<Point, Point\>, ValueTuple\<Point, Point\>\>](https://docs.microsoft.com/en-us/dotnet/api/System.ValueTuple-2)
### GetTextPosition(FormattedText, Point, Point)
```csharp
protected override Point GetTextPosition(FormattedText text, Point source, Point target);
```
**Parameters**
`text` [FormattedText](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.FormattedText)
`source` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`target` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
**Returns**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)

View File

@@ -0,0 +1,98 @@
# Connection Class
**Namespace:** Nodify
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [DispatcherObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Threading.DispatcherObject) → [DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject) → [Visual](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Visual) → [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement) → [FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement) → [Shape](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Shapes.Shape) → [BaseConnection](Nodify_BaseConnection) → [Connection](Nodify_Connection)
**References:** [Connector](Nodify_Connector), [NodifyEditor](Nodify_NodifyEditor)
Represents a cubic bezier curve.
```csharp
public class Connection : BaseConnection
```
## Constructors
### Connection()
```csharp
public Connection();
```
## Methods
### DrawDirectionalArrowsGeometry(StreamGeometryContext, Point, Point)
```csharp
protected override void DrawDirectionalArrowsGeometry(StreamGeometryContext context, Point source, Point target);
```
**Parameters**
`context` [StreamGeometryContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.StreamGeometryContext)
`source` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`target` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### DrawLineGeometry(StreamGeometryContext, Point, Point)
```csharp
protected override ValueTuple<ValueTuple<Point, Point>, ValueTuple<Point, Point>> DrawLineGeometry(StreamGeometryContext context, Point source, Point target);
```
**Parameters**
`context` [StreamGeometryContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.StreamGeometryContext)
`source` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`target` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
**Returns**
[ValueTuple\<ValueTuple\<Point, Point\>, ValueTuple\<Point, Point\>\>](https://docs.microsoft.com/en-us/dotnet/api/System.ValueTuple-2)
### GetTextPosition(FormattedText, Point, Point)
```csharp
protected override Point GetTextPosition(FormattedText text, Point source, Point target);
```
**Parameters**
`text` [FormattedText](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.FormattedText)
`source` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`target` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
**Returns**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### InterpolateCubicBezier(Point, Point, Point, Point, Double)
```csharp
protected static Point InterpolateCubicBezier(Point P0, Point P1, Point P2, Point P3, double t);
```
**Parameters**
`P0` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`P1` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`P2` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`P3` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
`t` [Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double)
**Returns**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)

View File

@@ -0,0 +1,165 @@
# ConnectionContainer Class
**Namespace:** Nodify
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [DispatcherObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Threading.DispatcherObject) → [DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject) → [Visual](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Visual) → [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement) → [FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement) → [ContentPresenter](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.ContentPresenter) → [ConnectionContainer](Nodify_ConnectionContainer)
**Implements:** [IKeyboardFocusTarget\<ConnectionContainer\>](Nodify_Interactivity_IKeyboardFocusTarget_TElement_)
**References:** [ConnectionsMultiSelector](Nodify_ConnectionsMultiSelector), [SelectionType](Nodify_SelectionType)
```csharp
public class ConnectionContainer : ContentPresenter, IKeyboardFocusTarget<ConnectionContainer>
```
## Constructors
### ConnectionContainer(ConnectionsMultiSelector)
```csharp
public ConnectionContainer(ConnectionsMultiSelector selector);
```
**Parameters**
`selector` [ConnectionsMultiSelector](Nodify_ConnectionsMultiSelector)
## Properties
### Bounds
```csharp
public virtual Rect Bounds { get; set; }
```
**Property Value**
[Rect](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Rect)
### Connection
```csharp
public FrameworkElement Connection { get; set; }
```
**Property Value**
[FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement)
### IsSelectable
Gets or sets whether this [ConnectionContainer](Nodify_ConnectionContainer) can be selected.
```csharp
public bool IsSelectable { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### IsSelected
Gets or sets a value that indicates whether this [ConnectionContainer](Nodify_ConnectionContainer) is selected.
Can only be set if [ConnectionContainer.IsSelectable](Nodify_ConnectionContainer#isselectable) is true.
```csharp
public bool IsSelected { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### Selector
```csharp
public ConnectionsMultiSelector Selector { get; set; }
```
**Property Value**
[ConnectionsMultiSelector](Nodify_ConnectionsMultiSelector)
## Methods
### OnIsKeyboardFocusedChanged(DependencyPropertyChangedEventArgs)
```csharp
protected override void OnIsKeyboardFocusedChanged(DependencyPropertyChangedEventArgs e);
```
**Parameters**
`e` [DependencyPropertyChangedEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyPropertyChangedEventArgs)
### OnMouseDown(MouseButtonEventArgs)
```csharp
protected override void OnMouseDown(MouseButtonEventArgs e);
```
**Parameters**
`e` [MouseButtonEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseButtonEventArgs)
### OnMouseUp(MouseButtonEventArgs)
```csharp
protected override void OnMouseUp(MouseButtonEventArgs e);
```
**Parameters**
`e` [MouseButtonEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseButtonEventArgs)
### OnVisualParentChanged(DependencyObject)
```csharp
protected override void OnVisualParentChanged(DependencyObject oldParent);
```
**Parameters**
`oldParent` [DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject)
### Select(SelectionType)
Modifies the selection state of the current item based on the specified selection type.
```csharp
public void Select(SelectionType type);
```
**Parameters**
`type` [SelectionType](Nodify_SelectionType): The type of selection to perform.
## Events
### Selected
Occurs when this [ConnectionContainer](Nodify_ConnectionContainer) is selected.
```csharp
public event RoutedEventHandler Selected;
```
**Event Type**
[RoutedEventHandler](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.RoutedEventHandler)
### Unselected
Occurs when this [ConnectionContainer](Nodify_ConnectionContainer) is unselected.
```csharp
public event RoutedEventHandler Unselected;
```
**Event Type**
[RoutedEventHandler](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.RoutedEventHandler)

View File

@@ -0,0 +1,32 @@
# ConnectionDirection Enum
**Namespace:** Nodify
**Assembly:** Nodify
**References:** [BaseConnection](Nodify_BaseConnection), [LineConnection](Nodify_LineConnection), [PendingConnection](Nodify_PendingConnection)
The direction in which a connection is oriented.
```csharp
public enum ConnectionDirection
```
## Fields
### Backward
From [BaseConnection.Target](Nodify_BaseConnection#target) to [BaseConnection.Source](Nodify_BaseConnection#source).
```csharp
Backward = 1;
```
### Forward
From [BaseConnection.Source](Nodify_BaseConnection#source) to [BaseConnection.Target](Nodify_BaseConnection#target).
```csharp
Forward = 0;
```

View File

@@ -0,0 +1,56 @@
# ConnectionOffsetMode Enum
**Namespace:** Nodify
**Assembly:** Nodify
**References:** [BaseConnection](Nodify_BaseConnection)
Specifies the offset type that can be applied to a [BaseConnection](Nodify_BaseConnection) using the [BaseConnection.SourceOffset](Nodify_BaseConnection#sourceoffset) and the [BaseConnection.TargetOffset](Nodify_BaseConnection#targetoffset) values.
```csharp
public enum ConnectionOffsetMode
```
## Fields
### Circle
The offset is applied in a circle around the point.
```csharp
Circle = 1;
```
### Edge
The offset is applied in a rectangle shape around the point, perpendicular to the edges.
```csharp
Edge = 3;
```
### None
No offset applied.
```csharp
None = 0;
```
### Rectangle
The offset is applied in a rectangle shape around the point.
```csharp
Rectangle = 2;
```
### Static
The offset is applied as a fixed margin.
```csharp
Static = 4;
```

View File

@@ -0,0 +1,184 @@
# ConnectionsMultiSelector Class
**Namespace:** Nodify
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [DispatcherObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Threading.DispatcherObject) → [DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject) → [Visual](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Visual) → [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement) → [FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement) → [Control](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.Control) → [ItemsControl](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.ItemsControl) → [Selector](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.Primitives.Selector) → [MultiSelector](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.Primitives.MultiSelector) → [ConnectionsMultiSelector](Nodify_ConnectionsMultiSelector)
**Implements:** [IKeyboardNavigationLayer](Nodify_Interactivity_IKeyboardNavigationLayer)
**References:** [ConnectionContainer](Nodify_ConnectionContainer), [IKeyboardFocusTarget\<ConnectionContainer\>](Nodify_Interactivity_IKeyboardFocusTarget_TElement_), [IKeyboardFocusTarget\<UIElement\>](Nodify_Interactivity_IKeyboardFocusTarget_TElement_), [KeyboardNavigationLayerId](Nodify_Interactivity_KeyboardNavigationLayerId), [NodifyEditor](Nodify_NodifyEditor)
```csharp
public class ConnectionsMultiSelector : MultiSelector, IKeyboardNavigationLayer
```
## Constructors
### ConnectionsMultiSelector()
```csharp
public ConnectionsMultiSelector();
```
## Properties
### CanSelectMultipleItems
Gets or sets whether multiple connections can be selected.
```csharp
public bool CanSelectMultipleItems { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### Editor
Gets the [NodifyEditor](Nodify_NodifyEditor) that owns this [ConnectionsMultiSelector](Nodify_ConnectionsMultiSelector).
```csharp
public NodifyEditor Editor { get; set; }
```
**Property Value**
[NodifyEditor](Nodify_NodifyEditor)
### Id
```csharp
public virtual KeyboardNavigationLayerId Id { get; set; }
```
**Property Value**
[KeyboardNavigationLayerId](Nodify_Interactivity_KeyboardNavigationLayerId)
### LastFocusedElement
```csharp
public virtual IKeyboardFocusTarget<UIElement> LastFocusedElement { get; set; }
```
**Property Value**
[IKeyboardFocusTarget\<UIElement\>](Nodify_Interactivity_IKeyboardFocusTarget_TElement_)
### SelectedItems
Gets or sets the selected connections in the [NodifyEditor](Nodify_NodifyEditor).
```csharp
public IList SelectedItems { get; set; }
```
**Property Value**
[IList](https://docs.microsoft.com/en-us/dotnet/api/System.Collections.IList)
## Methods
### FindNextFocusTarget(ConnectionContainer, TraversalRequest)
```csharp
protected virtual ConnectionContainer FindNextFocusTarget(ConnectionContainer currentContainer, TraversalRequest request);
```
**Parameters**
`currentContainer` [ConnectionContainer](Nodify_ConnectionContainer)
`request` [TraversalRequest](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.TraversalRequest)
**Returns**
[ConnectionContainer](Nodify_ConnectionContainer)
### GetContainerForItemOverride()
```csharp
protected override DependencyObject GetContainerForItemOverride();
```
**Returns**
[DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject)
### IsItemItsOwnContainerOverride(Object)
```csharp
protected override bool IsItemItsOwnContainerOverride(object item);
```
**Parameters**
`item` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### OnApplyTemplate()
```csharp
public override void OnApplyTemplate();
```
### OnElementFocused(IKeyboardFocusTarget\<ConnectionContainer\>)
```csharp
protected virtual void OnElementFocused(IKeyboardFocusTarget<ConnectionContainer> target);
```
**Parameters**
`target` [IKeyboardFocusTarget\<ConnectionContainer\>](Nodify_Interactivity_IKeyboardFocusTarget_TElement_)
### OnSelectionChanged(SelectionChangedEventArgs)
```csharp
protected override void OnSelectionChanged(SelectionChangedEventArgs e);
```
**Parameters**
`e` [SelectionChangedEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.SelectionChangedEventArgs)
### Select(ConnectionContainer)
```csharp
public void Select(ConnectionContainer container);
```
**Parameters**
`container` [ConnectionContainer](Nodify_ConnectionContainer)
### TryMoveFocus(TraversalRequest)
```csharp
public virtual bool TryMoveFocus(TraversalRequest request);
```
**Parameters**
`request` [TraversalRequest](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.TraversalRequest)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### TryRestoreFocus()
```csharp
public virtual bool TryRestoreFocus();
```
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)

View File

@@ -0,0 +1,476 @@
# Connector Class
**Namespace:** Nodify
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [DispatcherObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Threading.DispatcherObject) → [DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject) → [Visual](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Visual) → [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement) → [FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement) → [Control](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.Control) → [Connector](Nodify_Connector)
**Derived:** [NodeInput](Nodify_NodeInput), [NodeOutput](Nodify_NodeOutput), [StateNode](Nodify_StateNode)
**References:** [ConnectorState.Connecting](Nodify_Interactivity_ConnectorState_Connecting), [Connection](Nodify_Connection), [ConnectorEventArgs](Nodify_Events_ConnectorEventArgs), [ConnectorEventHandler](Nodify_Events_ConnectorEventHandler), [ConnectorState.Default](Nodify_Interactivity_ConnectorState_Default), [ConnectorState.Disconnect](Nodify_Interactivity_ConnectorState_Disconnect), [InputProcessor](Nodify_Interactivity_InputProcessor), [ItemContainer](Nodify_ItemContainer), [KnotNode](Nodify_KnotNode), [Node](Nodify_Node), [NodifyEditor](Nodify_NodifyEditor), [PendingConnection](Nodify_PendingConnection), [PendingConnectionEventArgs](Nodify_Events_PendingConnectionEventArgs), [PendingConnectionEventHandler](Nodify_Events_PendingConnectionEventHandler)
Represents a connector control that can start and complete a [PendingConnection](Nodify_PendingConnection).
Has a [Connector.ElementConnector](Nodify_Connector#elementconnector) that the [Connector.Anchor](Nodify_Connector#anchor) is calculated from for the [PendingConnection](Nodify_PendingConnection). Center of this control is used if missing.
```csharp
public class Connector : Control
```
## Constructors
### Connector()
```csharp
public Connector();
```
## Fields
### ElementConnector
```csharp
protected const string ElementConnector = "PART_Connector";
```
**Field Value**
[String](https://docs.microsoft.com/en-us/dotnet/api/System.String)
### EnableOptimizations
Gets or sets if [Connector](Nodify_Connector)s should enable optimizations based on [Connector.OptimizeSafeZone](Nodify_Connector#optimizesafezone) and [Connector.OptimizeMinimumSelectedItems](Nodify_Connector#optimizeminimumselecteditems).
```csharp
public static bool EnableOptimizations;
```
**Field Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### OptimizeMinimumSelectedItems
Gets or sets the minimum selected items needed to trigger optimizations when outside of the [Connector.OptimizeSafeZone](Nodify_Connector#optimizesafezone).
```csharp
public static uint OptimizeMinimumSelectedItems;
```
**Field Value**
[UInt32](https://docs.microsoft.com/en-us/dotnet/api/System.UInt32)
### OptimizeSafeZone
Gets or sets the safe zone outside the editor's viewport that will not trigger optimizations.
```csharp
public static double OptimizeSafeZone;
```
**Field Value**
[Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double)
## Properties
### AllowPendingConnectionCancellation
Gets or sets whether cancelling a pending connection is allowed.
```csharp
public static bool AllowPendingConnectionCancellation { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### Anchor
Gets the location in graph space coordinates where [Connection](Nodify_Connection)s can be attached to.
Bind with System.Windows.Data.BindingMode.OneWayToSource
```csharp
public Point Anchor { get; set; }
```
**Property Value**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### Container
Gets the [ItemContainer](Nodify_ItemContainer) that contains this [Connector](Nodify_Connector).
```csharp
public ItemContainer Container { get; set; }
```
**Property Value**
[ItemContainer](Nodify_ItemContainer)
### DisconnectCommand
Invoked if the [Connector.Disconnect](Nodify_Connector#disconnect) event is not handled.
Parameter is the [FrameworkElement.DataContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement#datacontext) of this control.
```csharp
public ICommand DisconnectCommand { get; set; }
```
**Property Value**
[ICommand](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ICommand)
### Editor
Gets the [NodifyEditor](Nodify_NodifyEditor) that owns this [Connector.Container](Nodify_Connector#container).
```csharp
public NodifyEditor Editor { get; set; }
```
**Property Value**
[NodifyEditor](Nodify_NodifyEditor)
### HasContextMenu
Gets a value indicating whether the connector has a context menu.
```csharp
public bool HasContextMenu { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### HasCustomContextMenu
Gets or sets a value indicating whether the connector uses a custom context menu.
```csharp
public bool HasCustomContextMenu { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### InputProcessor
```csharp
protected InputProcessor InputProcessor { get; set; }
```
**Property Value**
[InputProcessor](Nodify_Interactivity_InputProcessor)
### IsConnected
If this is set to false, the [Connector.Disconnect](Nodify_Connector#disconnect) event will not be invoked and the connector will stop updating its [Connector.Anchor](Nodify_Connector#anchor) when moved, resized etc.
```csharp
public bool IsConnected { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### IsPendingConnection
Gets a value that indicates whether a [PendingConnection](Nodify_PendingConnection) is in progress for this [Connector](Nodify_Connector).
```csharp
public bool IsPendingConnection { get; protected set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
## Methods
### BeginConnecting()
Initiates a new pending connection from this connector with the specified offset (see [Connector.IsPendingConnection](Nodify_Connector#ispendingconnection)).
```csharp
public void BeginConnecting();
```
### BeginConnecting(Vector)
```csharp
public void BeginConnecting(Vector offset);
```
**Parameters**
`offset` [Vector](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Vector)
### CancelConnecting()
Cancels the current pending connection without completing it if [Connector.AllowPendingConnectionCancellation](Nodify_Connector#allowpendingconnectioncancellation) is true.
Otherwise, it completes the pending connection by calling Nodify.Connector.EndConnecting.
```csharp
public void CancelConnecting();
```
### EndConnecting()
Completes the current pending connection using the specified connector as the target.
```csharp
public void EndConnecting();
```
### EndConnecting(Connector)
```csharp
public void EndConnecting(Connector connector);
```
**Parameters**
`connector` [Connector](Nodify_Connector)
### FindConnectionTarget(Point)
Searches for a potential [Connector](Nodify_Connector) or [ItemContainer](Nodify_ItemContainer) at the specified position within the editor.
```csharp
public FrameworkElement FindConnectionTarget(Point position);
```
**Parameters**
`position` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point): The position in the editor to check for a potential connection target.
**Returns**
[FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement)
### FindTargetConnector(Point)
Searches for a [Connector](Nodify_Connector) at the specified position.
```csharp
public Connector FindTargetConnector(Point position);
```
**Parameters**
`position` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point): The position in the editor to check for a connector.
**Returns**
[Connector](Nodify_Connector)
### OnApplyTemplate()
```csharp
public override void OnApplyTemplate();
```
### OnKeyDown(KeyEventArgs)
```csharp
protected override void OnKeyDown(KeyEventArgs e);
```
**Parameters**
`e` [KeyEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.KeyEventArgs)
### OnKeyUp(KeyEventArgs)
```csharp
protected override void OnKeyUp(KeyEventArgs e);
```
**Parameters**
`e` [KeyEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.KeyEventArgs)
### OnLostMouseCapture(MouseEventArgs)
```csharp
protected override void OnLostMouseCapture(MouseEventArgs e);
```
**Parameters**
`e` [MouseEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseEventArgs)
### OnMouseDown(MouseButtonEventArgs)
```csharp
protected override void OnMouseDown(MouseButtonEventArgs e);
```
**Parameters**
`e` [MouseButtonEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseButtonEventArgs)
### OnMouseMove(MouseEventArgs)
```csharp
protected override void OnMouseMove(MouseEventArgs e);
```
**Parameters**
`e` [MouseEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseEventArgs)
### OnMouseUp(MouseButtonEventArgs)
```csharp
protected override void OnMouseUp(MouseButtonEventArgs e);
```
**Parameters**
`e` [MouseButtonEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseButtonEventArgs)
### OnMouseWheel(MouseWheelEventArgs)
```csharp
protected override void OnMouseWheel(MouseWheelEventArgs e);
```
**Parameters**
`e` [MouseWheelEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseWheelEventArgs)
### OnRenderSizeChanged(SizeChangedInfo)
```csharp
protected override void OnRenderSizeChanged(SizeChangedInfo sizeInfo);
```
**Parameters**
`sizeInfo` [SizeChangedInfo](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.SizeChangedInfo)
### RemoveConnections()
Removes all connections associated with this connector.
```csharp
public void RemoveConnections();
```
### UpdateAnchor(Point)
Updates the [Connector.Anchor](Nodify_Connector#anchor) relative to a location. (usually [Connector.Container](Nodify_Connector#container)'s location)
```csharp
protected void UpdateAnchor(Point location);
```
**Parameters**
`location` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point): The relative location
### UpdateAnchor()
Updates the [Connector.Anchor](Nodify_Connector#anchor) based on [Connector.Container](Nodify_Connector#container)'s location.
```csharp
public void UpdateAnchor();
```
### UpdateAnchorOptimized(Point)
Updates the [Connector.Anchor](Nodify_Connector#anchor) and applies optimizations if needed based on [Connector.EnableOptimizations](Nodify_Connector#enableoptimizations) flag
```csharp
protected void UpdateAnchorOptimized(Point location);
```
**Parameters**
`location` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### UpdatePendingConnection(Vector)
Updates the endpoint of the pending connection by adjusting its position with the specified offset.
```csharp
public void UpdatePendingConnection(Vector offset);
```
**Parameters**
`offset` [Vector](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Vector): The amount to adjust the pending connection's endpoint.
### UpdatePendingConnection(Point)
Updates the endpoint of the pending connection to the specified position.
```csharp
public void UpdatePendingConnection(Point position);
```
**Parameters**
`position` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point): The new position for the connection's endpoint.
## Events
### Disconnect
Triggered by the Nodify.Interactivity.EditorGestures.ConnectorGestures.Disconnect gesture.
```csharp
public event ConnectorEventHandler Disconnect;
```
**Event Type**
[ConnectorEventHandler](Nodify_Events_ConnectorEventHandler)
### PendingConnectionCompleted
Triggered by the Nodify.Interactivity.EditorGestures.ConnectorGestures.Connect gesture.
```csharp
public event PendingConnectionEventHandler PendingConnectionCompleted;
```
**Event Type**
[PendingConnectionEventHandler](Nodify_Events_PendingConnectionEventHandler)
### PendingConnectionDrag
Occurs when the mouse is changing position and the [Connector](Nodify_Connector) has mouse capture.
```csharp
public event PendingConnectionEventHandler PendingConnectionDrag;
```
**Event Type**
[PendingConnectionEventHandler](Nodify_Events_PendingConnectionEventHandler)
### PendingConnectionStarted
Triggered by the Nodify.Interactivity.EditorGestures.ConnectorGestures.Connect gesture.
```csharp
public event PendingConnectionEventHandler PendingConnectionStarted;
```
**Event Type**
[PendingConnectionEventHandler](Nodify_Events_PendingConnectionEventHandler)

View File

@@ -0,0 +1,38 @@
# ConnectorPosition Enum
**Namespace:** Nodify
**Assembly:** Nodify
**References:** [StepConnection](Nodify_StepConnection)
```csharp
public enum ConnectorPosition
```
## Fields
### Bottom
```csharp
Bottom = 2;
```
### Left
```csharp
Left = 1;
```
### Right
```csharp
Right = 3;
```
### Top
```csharp
Top = 0;
```

View File

@@ -0,0 +1,96 @@
# CuttingLine Class
**Namespace:** Nodify
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [DispatcherObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Threading.DispatcherObject) → [DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject) → [Visual](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Visual) → [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement) → [FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement) → [Shape](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Shapes.Shape) → [CuttingLine](Nodify_CuttingLine)
**References:** [BaseConnection](Nodify_BaseConnection), [NodifyEditor](Nodify_NodifyEditor)
```csharp
public class CuttingLine : Shape
```
## Constructors
### CuttingLine()
```csharp
public CuttingLine();
```
## Properties
### DefiningGeometry
```csharp
protected override Geometry DefiningGeometry { get; set; }
```
**Property Value**
[Geometry](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Geometry)
### EndPoint
Gets or sets the end point.
```csharp
public Point EndPoint { get; set; }
```
**Property Value**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### StartPoint
Gets or sets the start point.
```csharp
public Point StartPoint { get; set; }
```
**Property Value**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
## Methods
### GetIsOverElement(UIElement)
```csharp
public static bool GetIsOverElement(UIElement elem);
```
**Parameters**
`elem` [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### OnRender(DrawingContext)
```csharp
protected override void OnRender(DrawingContext drawingContext);
```
**Parameters**
`drawingContext` [DrawingContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.DrawingContext)
### SetIsOverElement(UIElement, Boolean)
```csharp
public static void SetIsOverElement(UIElement elem, bool value);
```
**Parameters**
`elem` [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement)
`value` [Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)

View File

@@ -0,0 +1,126 @@
# DecoratorContainer Class
**Namespace:** Nodify
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [DispatcherObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Threading.DispatcherObject) → [DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject) → [Visual](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Visual) → [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement) → [FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement) → [Control](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.Control) → [ContentControl](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.ContentControl) → [DecoratorContainer](Nodify_DecoratorContainer)
**Implements:** [INodifyCanvasItem](Nodify_INodifyCanvasItem), [IKeyboardFocusTarget\<DecoratorContainer\>](Nodify_Interactivity_IKeyboardFocusTarget_TElement_)
**References:** [DecoratorsControl](Nodify_DecoratorsControl), [NodifyEditor](Nodify_NodifyEditor)
The container for all the items generated from the [NodifyEditor.Decorators](Nodify_NodifyEditor#decorators) collection.
```csharp
public class DecoratorContainer : ContentControl, INodifyCanvasItem, IKeyboardFocusTarget<DecoratorContainer>
```
## Constructors
### DecoratorContainer(DecoratorsControl)
```csharp
public DecoratorContainer(DecoratorsControl parent);
```
**Parameters**
`parent` [DecoratorsControl](Nodify_DecoratorsControl)
### DecoratorContainer()
```csharp
public DecoratorContainer();
```
## Properties
### ActualSize
Gets the actual size of this [DecoratorContainer](Nodify_DecoratorContainer).
```csharp
public Size ActualSize { get; set; }
```
**Property Value**
[Size](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Size)
### Bounds
```csharp
public virtual Rect Bounds { get; set; }
```
**Property Value**
[Rect](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Rect)
### Location
Gets or sets the location of this [DecoratorContainer](Nodify_DecoratorContainer) inside the NodifyEditor.DecoratorsHost.
```csharp
public virtual Point Location { get; set; }
```
**Property Value**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### Owner
```csharp
public DecoratorsControl Owner { get; set; }
```
**Property Value**
[DecoratorsControl](Nodify_DecoratorsControl)
## Methods
### OnLocationChanged()
Raises the [DecoratorContainer.LocationChangedEvent](Nodify_DecoratorContainer#locationchangedevent).
```csharp
protected void OnLocationChanged();
```
### OnRenderSizeChanged(SizeChangedInfo)
```csharp
protected override void OnRenderSizeChanged(SizeChangedInfo sizeInfo);
```
**Parameters**
`sizeInfo` [SizeChangedInfo](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.SizeChangedInfo)
### OnVisualParentChanged(DependencyObject)
```csharp
protected override void OnVisualParentChanged(DependencyObject oldParent);
```
**Parameters**
`oldParent` [DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject)
## Events
### LocationChanged
Occurs when the [DecoratorContainer.Location](Nodify_DecoratorContainer#location) of this [DecoratorContainer](Nodify_DecoratorContainer) is changed.
```csharp
public event RoutedEventHandler LocationChanged;
```
**Event Type**
[RoutedEventHandler](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.RoutedEventHandler)

View File

@@ -0,0 +1,142 @@
# DecoratorsControl Class
**Namespace:** Nodify
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [DispatcherObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Threading.DispatcherObject) → [DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject) → [Visual](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Visual) → [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement) → [FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement) → [Control](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.Control) → [ItemsControl](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.ItemsControl) → [DecoratorsControl](Nodify_DecoratorsControl)
**Implements:** [IKeyboardNavigationLayer](Nodify_Interactivity_IKeyboardNavigationLayer)
**References:** [DecoratorContainer](Nodify_DecoratorContainer), [IKeyboardFocusTarget\<DecoratorContainer\>](Nodify_Interactivity_IKeyboardFocusTarget_TElement_), [IKeyboardFocusTarget\<UIElement\>](Nodify_Interactivity_IKeyboardFocusTarget_TElement_), [KeyboardNavigationLayerId](Nodify_Interactivity_KeyboardNavigationLayerId), [NodifyEditor](Nodify_NodifyEditor)
An [ItemsControl](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.ItemsControl) that works with [DecoratorContainer](Nodify_DecoratorContainer)s.
```csharp
public class DecoratorsControl : ItemsControl, IKeyboardNavigationLayer
```
## Constructors
### DecoratorsControl()
```csharp
public DecoratorsControl();
```
## Properties
### Editor
Gets the [NodifyEditor](Nodify_NodifyEditor) that owns this [DecoratorsControl](Nodify_DecoratorsControl).
```csharp
public NodifyEditor Editor { get; set; }
```
**Property Value**
[NodifyEditor](Nodify_NodifyEditor)
### Id
```csharp
public virtual KeyboardNavigationLayerId Id { get; set; }
```
**Property Value**
[KeyboardNavigationLayerId](Nodify_Interactivity_KeyboardNavigationLayerId)
### LastFocusedElement
```csharp
public virtual IKeyboardFocusTarget<UIElement> LastFocusedElement { get; set; }
```
**Property Value**
[IKeyboardFocusTarget\<UIElement\>](Nodify_Interactivity_IKeyboardFocusTarget_TElement_)
## Methods
### FindNextFocusTarget(DecoratorContainer, TraversalRequest)
```csharp
protected virtual DecoratorContainer FindNextFocusTarget(DecoratorContainer currentContainer, TraversalRequest request);
```
**Parameters**
`currentContainer` [DecoratorContainer](Nodify_DecoratorContainer)
`request` [TraversalRequest](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.TraversalRequest)
**Returns**
[DecoratorContainer](Nodify_DecoratorContainer)
### GetContainerForItemOverride()
```csharp
protected override DependencyObject GetContainerForItemOverride();
```
**Returns**
[DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject)
### IsItemItsOwnContainerOverride(Object)
```csharp
protected override bool IsItemItsOwnContainerOverride(object item);
```
**Parameters**
`item` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### OnApplyTemplate()
```csharp
public override void OnApplyTemplate();
```
### OnElementFocused(IKeyboardFocusTarget\<DecoratorContainer\>)
```csharp
protected virtual void OnElementFocused(IKeyboardFocusTarget<DecoratorContainer> target);
```
**Parameters**
`target` [IKeyboardFocusTarget\<DecoratorContainer\>](Nodify_Interactivity_IKeyboardFocusTarget_TElement_)
### TryMoveFocus(TraversalRequest)
```csharp
public virtual bool TryMoveFocus(TraversalRequest request);
```
**Parameters**
`request` [TraversalRequest](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.TraversalRequest)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### TryRestoreFocus()
```csharp
public virtual bool TryRestoreFocus();
```
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)

View File

@@ -0,0 +1,116 @@
# EditorCommands Class
**Namespace:** Nodify
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EditorCommands](Nodify_EditorCommands)
**References:** [Alignment](Nodify_Alignment), [InputGestureRef](Nodify_Interactivity_InputGestureRef), [ItemContainer](Nodify_ItemContainer), [NodifyEditor](Nodify_NodifyEditor)
Provides common commands for the [NodifyEditor](Nodify_NodifyEditor).
```csharp
public static class EditorCommands
```
## Properties
### Align
Aligns the [NodifyEditor.SelectedContainers](Nodify_NodifyEditor#selectedcontainers) using the specified alignment method.
Parameter is of type [Alignment](Nodify_Alignment) or a string that can be converted to an alignment.
```csharp
public static RoutedUICommand Align { get; set; }
```
**Property Value**
[RoutedUICommand](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.RoutedUICommand)
### BringIntoView
Moves the [NodifyEditor.ViewportLocation](Nodify_NodifyEditor#viewportlocation) to the specified location.
Parameter is a [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point) or a string that can be converted to a point.
```csharp
public static RoutedUICommand BringIntoView { get; set; }
```
**Property Value**
[RoutedUICommand](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.RoutedUICommand)
### FitToScreen
Scales the editor's viewport to fit all the [ItemContainer](Nodify_ItemContainer)s if that's possible.
```csharp
public static RoutedUICommand FitToScreen { get; set; }
```
**Property Value**
[RoutedUICommand](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.RoutedUICommand)
### LockSelection
Locks the position of the [NodifyEditor.SelectedContainers](Nodify_NodifyEditor#selectedcontainers).
```csharp
public static RoutedUICommand LockSelection { get; set; }
```
**Property Value**
[RoutedUICommand](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.RoutedUICommand)
### SelectAll
Select all [ItemContainer](Nodify_ItemContainer)s in the [NodifyEditor](Nodify_NodifyEditor).
```csharp
public static RoutedUICommand SelectAll { get; set; }
```
**Property Value**
[RoutedUICommand](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.RoutedUICommand)
### UnlockSelection
Unlocks the position of the [NodifyEditor.SelectedContainers](Nodify_NodifyEditor#selectedcontainers).
```csharp
public static RoutedUICommand UnlockSelection { get; set; }
```
**Property Value**
[RoutedUICommand](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.RoutedUICommand)
### ZoomIn
Zoom in relative to the editor's viewport center.
```csharp
public static RoutedUICommand ZoomIn { get; set; }
```
**Property Value**
[RoutedUICommand](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.RoutedUICommand)
### ZoomOut
Zoom out relative to the editor's viewport center.
```csharp
public static RoutedUICommand ZoomOut { get; set; }
```
**Property Value**
[RoutedUICommand](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.RoutedUICommand)

View File

@@ -0,0 +1,70 @@
# ConnectionEventArgs Class
**Namespace:** Nodify.Events
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.EventArgs) → [RoutedEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.RoutedEventArgs) → [ConnectionEventArgs](Nodify_Events_ConnectionEventArgs)
**References:** [BaseConnection](Nodify_BaseConnection), [ConnectionEventHandler](Nodify_Events_ConnectionEventHandler)
Provides data for [BaseConnection](Nodify_BaseConnection) related routed events.
```csharp
public class ConnectionEventArgs : RoutedEventArgs
```
## Constructors
### ConnectionEventArgs(Object)
Initializes a new instance of the [ConnectionEventArgs](Nodify_Events_ConnectionEventArgs) class using the specified [ConnectionEventArgs.Connection](Nodify_Events_ConnectionEventArgs#connection).
```csharp
public ConnectionEventArgs(object connection);
```
**Parameters**
`connection` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object): The [FrameworkElement.DataContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement#datacontext) of a related [BaseConnection](Nodify_BaseConnection).
## Properties
### Connection
Gets the [FrameworkElement.DataContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement#datacontext) of the [BaseConnection](Nodify_BaseConnection) associated with this event.
```csharp
public object Connection { get; set; }
```
**Property Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### SplitLocation
Gets or sets the location where the connection should be split.
```csharp
public Point SplitLocation { get; set; }
```
**Property Value**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
## Methods
### InvokeEventHandler(Delegate, Object)
```csharp
protected override void InvokeEventHandler(Delegate genericHandler, object genericTarget);
```
**Parameters**
`genericHandler` [Delegate](https://docs.microsoft.com/en-us/dotnet/api/System.Delegate)
`genericTarget` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)

View File

@@ -0,0 +1,22 @@
# ConnectionEventHandler Delegate
**Namespace:** Nodify.Events
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [Delegate](https://docs.microsoft.com/en-us/dotnet/api/System.Delegate) → [MulticastDelegate](https://docs.microsoft.com/en-us/dotnet/api/System.MulticastDelegate) → [ConnectionEventHandler](Nodify_Events_ConnectionEventHandler)
**References:** [BaseConnection](Nodify_BaseConnection), [ConnectionEventArgs](Nodify_Events_ConnectionEventArgs)
Represents the method that will handle [BaseConnection](Nodify_BaseConnection) related routed events.
```csharp
public delegate void ConnectionEventHandler(object sender, ConnectionEventArgs e);
```
**Parameters**
`sender` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object): The object where the event handler is attached.
`e` [ConnectionEventArgs](Nodify_Events_ConnectionEventArgs): The event data.

View File

@@ -0,0 +1,70 @@
# ConnectorEventArgs Class
**Namespace:** Nodify.Events
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.EventArgs) → [RoutedEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.RoutedEventArgs) → [ConnectorEventArgs](Nodify_Events_ConnectorEventArgs)
**References:** [Connector](Nodify_Connector), [ConnectorEventHandler](Nodify_Events_ConnectorEventHandler)
Provides data for [Connector](Nodify_Connector) related routed events.
```csharp
public class ConnectorEventArgs : RoutedEventArgs
```
## Constructors
### ConnectorEventArgs(Object)
Initializes a new instance of the [ConnectorEventArgs](Nodify_Events_ConnectorEventArgs) class using the specified [ConnectorEventArgs.Connector](Nodify_Events_ConnectorEventArgs#connector).
```csharp
public ConnectorEventArgs(object connector);
```
**Parameters**
`connector` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object): The [FrameworkElement.DataContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement#datacontext) of a related [Connector](Nodify_Connector).
## Properties
### Anchor
Gets or sets the [Connector.Anchor](Nodify_Connector#anchor) of the [Connector](Nodify_Connector) associated with this event.
```csharp
public Point Anchor { get; set; }
```
**Property Value**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### Connector
Gets the [FrameworkElement.DataContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement#datacontext) of the [Connector](Nodify_Connector) associated with this event.
```csharp
public object Connector { get; set; }
```
**Property Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
## Methods
### InvokeEventHandler(Delegate, Object)
```csharp
protected override void InvokeEventHandler(Delegate genericHandler, object genericTarget);
```
**Parameters**
`genericHandler` [Delegate](https://docs.microsoft.com/en-us/dotnet/api/System.Delegate)
`genericTarget` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)

View File

@@ -0,0 +1,22 @@
# ConnectorEventHandler Delegate
**Namespace:** Nodify.Events
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [Delegate](https://docs.microsoft.com/en-us/dotnet/api/System.Delegate) → [MulticastDelegate](https://docs.microsoft.com/en-us/dotnet/api/System.MulticastDelegate) → [ConnectorEventHandler](Nodify_Events_ConnectorEventHandler)
**References:** [Connector](Nodify_Connector), [ConnectorEventArgs](Nodify_Events_ConnectorEventArgs)
Represents the method that will handle [Connector](Nodify_Connector) related routed events.
```csharp
public delegate void ConnectorEventHandler(object sender, ConnectorEventArgs e);
```
**Parameters**
`sender` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object): The object where the event handler is attached.
`e` [ConnectorEventArgs](Nodify_Events_ConnectorEventArgs): The event data.

View File

@@ -0,0 +1,72 @@
# ItemsMovedEventArgs Class
**Namespace:** Nodify.Events
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.EventArgs) → [RoutedEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.RoutedEventArgs) → [ItemsMovedEventArgs](Nodify_Events_ItemsMovedEventArgs)
**References:** [ItemContainer](Nodify_ItemContainer), [ItemsMovedEventHandler](Nodify_Events_ItemsMovedEventHandler), [NodifyEditor](Nodify_NodifyEditor)
Provides data for the [NodifyEditor.ItemsMovedEvent](Nodify_NodifyEditor#itemsmovedevent) routed event.
```csharp
public class ItemsMovedEventArgs : RoutedEventArgs
```
## Constructors
### ItemsMovedEventArgs(IReadOnlyCollection\<Object\>, Vector)
Initializes a new instance of the [ItemsMovedEventArgs](Nodify_Events_ItemsMovedEventArgs) class with the specified moved items and offset.
```csharp
public ItemsMovedEventArgs(IReadOnlyCollection<Object> items, Vector offset);
```
**Parameters**
`items` [IReadOnlyCollection\<Object\>](https://docs.microsoft.com/en-us/dotnet/api/System.Collections.Generic.IReadOnlyCollection-1): The collection of items that were moved.
`offset` [Vector](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Vector): The vector representing the distance the items were moved.
## Properties
### Items
Gets a collection of [FrameworkElement.DataContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement#datacontext)s of the [ItemContainer](Nodify_ItemContainer)s associated with this event.
```csharp
public IReadOnlyCollection<Object> Items { get; set; }
```
**Property Value**
[IReadOnlyCollection\<Object\>](https://docs.microsoft.com/en-us/dotnet/api/System.Collections.Generic.IReadOnlyCollection-1)
### Offset
Gets or sets the vector representing the distance the items were moved.
```csharp
public Vector Offset { get; set; }
```
**Property Value**
[Vector](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Vector)
## Methods
### InvokeEventHandler(Delegate, Object)
```csharp
protected override void InvokeEventHandler(Delegate genericHandler, object genericTarget);
```
**Parameters**
`genericHandler` [Delegate](https://docs.microsoft.com/en-us/dotnet/api/System.Delegate)
`genericTarget` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)

View File

@@ -0,0 +1,22 @@
# ItemsMovedEventHandler Delegate
**Namespace:** Nodify.Events
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [Delegate](https://docs.microsoft.com/en-us/dotnet/api/System.Delegate) → [MulticastDelegate](https://docs.microsoft.com/en-us/dotnet/api/System.MulticastDelegate) → [ItemsMovedEventHandler](Nodify_Events_ItemsMovedEventHandler)
**References:** [ItemsMovedEventArgs](Nodify_Events_ItemsMovedEventArgs), [NodifyEditor](Nodify_NodifyEditor)
Represents a method signature used to handle the [NodifyEditor.ItemsMovedEvent](Nodify_NodifyEditor#itemsmovedevent) routed event.
```csharp
public delegate void ItemsMovedEventHandler(object sender, ItemsMovedEventArgs e);
```
**Parameters**
`sender` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object): The source of the event.
`e` [ItemsMovedEventArgs](Nodify_Events_ItemsMovedEventArgs): The event data containing information about the moved items and their offset.

View File

@@ -0,0 +1,118 @@
# PendingConnectionEventArgs Class
**Namespace:** Nodify.Events
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.EventArgs) → [RoutedEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.RoutedEventArgs) → [PendingConnectionEventArgs](Nodify_Events_PendingConnectionEventArgs)
**References:** [Connector](Nodify_Connector), [PendingConnection](Nodify_PendingConnection), [PendingConnectionEventHandler](Nodify_Events_PendingConnectionEventHandler)
Provides data for [PendingConnection](Nodify_PendingConnection) related routed events.
```csharp
public class PendingConnectionEventArgs : RoutedEventArgs
```
## Constructors
### PendingConnectionEventArgs(Object)
Initializes a new instance of the [PendingConnectionEventArgs](Nodify_Events_PendingConnectionEventArgs) class using the specified [PendingConnectionEventArgs.SourceConnector](Nodify_Events_PendingConnectionEventArgs#sourceconnector).
```csharp
public PendingConnectionEventArgs(object sourceConnector);
```
**Parameters**
`sourceConnector` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object): The [FrameworkElement.DataContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement#datacontext) of a related [Connector](Nodify_Connector).
## Properties
### Anchor
Gets or sets the [Connector.Anchor](Nodify_Connector#anchor) of the [Connector](Nodify_Connector) that raised this event.
```csharp
public Point Anchor { get; set; }
```
**Property Value**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### Canceled
Gets or sets a value that indicates whether this [PendingConnection](Nodify_PendingConnection) was cancelled.
```csharp
public bool Canceled { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### OffsetX
Gets or sets the distance from the [PendingConnectionEventArgs.SourceConnector](Nodify_Events_PendingConnectionEventArgs#sourceconnector) in the X axis.
```csharp
public double OffsetX { get; set; }
```
**Property Value**
[Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double)
### OffsetY
Gets or sets the distance from the [PendingConnectionEventArgs.SourceConnector](Nodify_Events_PendingConnectionEventArgs#sourceconnector) in the Y axis.
```csharp
public double OffsetY { get; set; }
```
**Property Value**
[Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double)
### SourceConnector
Gets the [FrameworkElement.DataContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement#datacontext) of the [Connector](Nodify_Connector) that started this [PendingConnection](Nodify_PendingConnection).
```csharp
public object SourceConnector { get; set; }
```
**Property Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### TargetConnector
Gets or sets the [FrameworkElement.DataContext](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement#datacontext) of the target [Connector](Nodify_Connector) when the [PendingConnection](Nodify_PendingConnection) is completed.
```csharp
public object TargetConnector { get; set; }
```
**Property Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
## Methods
### InvokeEventHandler(Delegate, Object)
```csharp
protected override void InvokeEventHandler(Delegate genericHandler, object genericTarget);
```
**Parameters**
`genericHandler` [Delegate](https://docs.microsoft.com/en-us/dotnet/api/System.Delegate)
`genericTarget` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)

View File

@@ -0,0 +1,22 @@
# PendingConnectionEventHandler Delegate
**Namespace:** Nodify.Events
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [Delegate](https://docs.microsoft.com/en-us/dotnet/api/System.Delegate) → [MulticastDelegate](https://docs.microsoft.com/en-us/dotnet/api/System.MulticastDelegate) → [PendingConnectionEventHandler](Nodify_Events_PendingConnectionEventHandler)
**References:** [Connector](Nodify_Connector), [PendingConnection](Nodify_PendingConnection), [PendingConnectionEventArgs](Nodify_Events_PendingConnectionEventArgs)
Represents the method that will handle [PendingConnection](Nodify_PendingConnection) related routed events.
```csharp
public delegate void PendingConnectionEventHandler(object sender, PendingConnectionEventArgs e);
```
**Parameters**
`sender` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object): The object where the event handler is attached.
`e` [PendingConnectionEventArgs](Nodify_Events_PendingConnectionEventArgs): The event data.

View File

@@ -0,0 +1,20 @@
# PreviewLocationChanged Delegate
**Namespace:** Nodify.Events
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [Delegate](https://docs.microsoft.com/en-us/dotnet/api/System.Delegate) → [MulticastDelegate](https://docs.microsoft.com/en-us/dotnet/api/System.MulticastDelegate) → [PreviewLocationChanged](Nodify_Events_PreviewLocationChanged)
**References:** [ItemContainer](Nodify_ItemContainer)
Delegate used to notify when an [ItemContainer](Nodify_ItemContainer) is previewing a new location.
```csharp
public delegate void PreviewLocationChanged(Point newLocation);
```
**Parameters**
`newLocation` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point): The new location.

View File

@@ -0,0 +1,72 @@
# ResizeEventArgs Class
**Namespace:** Nodify.Events
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.EventArgs) → [RoutedEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.RoutedEventArgs) → [ResizeEventArgs](Nodify_Events_ResizeEventArgs)
**References:** [ResizeEventHandler](Nodify_Events_ResizeEventHandler)
Provides data for resize related routed events.
```csharp
public class ResizeEventArgs : RoutedEventArgs
```
## Constructors
### ResizeEventArgs(Size, Size)
Initializes a new instance of the [ResizeEventArgs](Nodify_Events_ResizeEventArgs) class with the previous and the new [Size](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Size).
```csharp
public ResizeEventArgs(Size previousSize, Size newSize);
```
**Parameters**
`previousSize` [Size](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Size): The previous size associated with this event.
`newSize` [Size](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Size): The new size associated with this event.
## Properties
### NewSize
Gets the new size of the object.
```csharp
public Size NewSize { get; set; }
```
**Property Value**
[Size](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Size)
### PreviousSize
Gets the previous size of the object.
```csharp
public Size PreviousSize { get; set; }
```
**Property Value**
[Size](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Size)
## Methods
### InvokeEventHandler(Delegate, Object)
```csharp
protected override void InvokeEventHandler(Delegate genericHandler, object genericTarget);
```
**Parameters**
`genericHandler` [Delegate](https://docs.microsoft.com/en-us/dotnet/api/System.Delegate)
`genericTarget` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)

View File

@@ -0,0 +1,22 @@
# ResizeEventHandler Delegate
**Namespace:** Nodify.Events
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [Delegate](https://docs.microsoft.com/en-us/dotnet/api/System.Delegate) → [MulticastDelegate](https://docs.microsoft.com/en-us/dotnet/api/System.MulticastDelegate) → [ResizeEventHandler](Nodify_Events_ResizeEventHandler)
**References:** [GroupingNode](Nodify_GroupingNode), [ResizeEventArgs](Nodify_Events_ResizeEventArgs)
Represents the method that will handle resize related routed events.
```csharp
public delegate void ResizeEventHandler(object sender, ResizeEventArgs e);
```
**Parameters**
`sender` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object): The sender of this event.
`e` [ResizeEventArgs](Nodify_Events_ResizeEventArgs): The event data.

View File

@@ -0,0 +1,72 @@
# ZoomEventArgs Class
**Namespace:** Nodify.Events
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.EventArgs) → [RoutedEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.RoutedEventArgs) → [ZoomEventArgs](Nodify_Events_ZoomEventArgs)
**References:** [Minimap](Nodify_Minimap), [ZoomEventHandler](Nodify_Events_ZoomEventHandler)
Provides data for [Minimap.Zoom](Nodify_Minimap#zoom) routed event.
```csharp
public class ZoomEventArgs : RoutedEventArgs
```
## Constructors
### ZoomEventArgs(Double, Point)
Initializes a new instance of the [ZoomEventArgs](Nodify_Events_ZoomEventArgs) class using the specified [ZoomEventArgs.Zoom](Nodify_Events_ZoomEventArgs#zoom) and [ZoomEventArgs.Location](Nodify_Events_ZoomEventArgs#location).
```csharp
public ZoomEventArgs(double zoom, Point location);
```
**Parameters**
`zoom` [Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double)
`location` [Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
## Properties
### Location
Gets the location where the editor should zoom in.
```csharp
public Point Location { get; set; }
```
**Property Value**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### Zoom
Gets the zoom amount.
```csharp
public double Zoom { get; set; }
```
**Property Value**
[Double](https://docs.microsoft.com/en-us/dotnet/api/System.Double)
## Methods
### InvokeEventHandler(Delegate, Object)
```csharp
protected override void InvokeEventHandler(Delegate genericHandler, object genericTarget);
```
**Parameters**
`genericHandler` [Delegate](https://docs.microsoft.com/en-us/dotnet/api/System.Delegate)
`genericTarget` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)

View File

@@ -0,0 +1,22 @@
# ZoomEventHandler Delegate
**Namespace:** Nodify.Events
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [Delegate](https://docs.microsoft.com/en-us/dotnet/api/System.Delegate) → [MulticastDelegate](https://docs.microsoft.com/en-us/dotnet/api/System.MulticastDelegate) → [ZoomEventHandler](Nodify_Events_ZoomEventHandler)
**References:** [Minimap](Nodify_Minimap), [ZoomEventArgs](Nodify_Events_ZoomEventArgs)
Represents the method that will handle [Minimap.Zoom](Nodify_Minimap#zoom) routed event.
```csharp
public delegate void ZoomEventHandler(object sender, ZoomEventArgs e);
```
**Parameters**
`sender` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object): The object where the event handler is attached.
`e` [ZoomEventArgs](Nodify_Events_ZoomEventArgs): The event data.

View File

@@ -0,0 +1,32 @@
# GroupingMovementMode Enum
**Namespace:** Nodify
**Assembly:** Nodify
**References:** [GroupingNode](Nodify_GroupingNode)
Specifies the possible movement modes of a [GroupingNode](Nodify_GroupingNode).
```csharp
public enum GroupingMovementMode
```
## Fields
### Group
The [GroupingNode](Nodify_GroupingNode) will move its content when moved.
```csharp
Group = 0;
```
### Self
The [GroupingNode](Nodify_GroupingNode) will not move its content when moved.
```csharp
Self = 1;
```

View File

@@ -0,0 +1,248 @@
# GroupingNode Class
**Namespace:** Nodify
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [DispatcherObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Threading.DispatcherObject) → [DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject) → [Visual](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Visual) → [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement) → [FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement) → [Control](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.Control) → [ContentControl](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.ContentControl) → [HeaderedContentControl](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.HeaderedContentControl) → [GroupingNode](Nodify_GroupingNode)
**References:** [GroupingMovementMode](Nodify_GroupingMovementMode), [ItemContainer](Nodify_ItemContainer), [NodifyEditor](Nodify_NodifyEditor), [ResizeEventHandler](Nodify_Events_ResizeEventHandler)
Defines a panel with a header that groups [ItemContainer](Nodify_ItemContainer)s inside it and can be resized.
```csharp
public class GroupingNode : HeaderedContentControl
```
## Constructors
### GroupingNode()
Initializes a new instance of the [GroupingNode](Nodify_GroupingNode) class.
```csharp
public GroupingNode();
```
## Fields
### ContentControl
Gets the [ContentControl](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.ContentControl) control of this [GroupingNode](Nodify_GroupingNode).
```csharp
protected FrameworkElement ContentControl;
```
**Field Value**
[FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement)
### ElementContent
```csharp
protected const string ElementContent = "PART_Content";
```
**Field Value**
[String](https://docs.microsoft.com/en-us/dotnet/api/System.String)
### ElementHeader
```csharp
protected const string ElementHeader = "PART_Header";
```
**Field Value**
[String](https://docs.microsoft.com/en-us/dotnet/api/System.String)
### ElementResizeThumb
```csharp
protected const string ElementResizeThumb = "PART_ResizeThumb";
```
**Field Value**
[String](https://docs.microsoft.com/en-us/dotnet/api/System.String)
### GroupMovementBoxed
```csharp
protected static object GroupMovementBoxed;
```
**Field Value**
[Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
### HeaderControl
Gets the [HeaderedContentControl.Header](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.HeaderedContentControl#header) control of this [GroupingNode](Nodify_GroupingNode).
```csharp
protected FrameworkElement HeaderControl;
```
**Field Value**
[FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement)
### ResizeThumb
Gets the [FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement) used to resize this [GroupingNode](Nodify_GroupingNode).
```csharp
protected FrameworkElement ResizeThumb;
```
**Field Value**
[FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement)
## Properties
### ActualSize
Gets or sets the actual size of this [GroupingNode](Nodify_GroupingNode).
```csharp
public Size ActualSize { get; set; }
```
**Property Value**
[Size](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Size)
### CanResize
Gets or sets a value that indicates whether this [GroupingNode](Nodify_GroupingNode) can be resized.
```csharp
public bool CanResize { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### Container
Gets the [NodifyEditor](Nodify_NodifyEditor) that owns this [GroupingNode.Container](Nodify_GroupingNode#container).
```csharp
protected ItemContainer Container { get; set; }
```
**Property Value**
[ItemContainer](Nodify_ItemContainer)
### Editor
Gets the [NodifyEditor](Nodify_NodifyEditor) that owns this [GroupingNode](Nodify_GroupingNode).
```csharp
protected NodifyEditor Editor { get; set; }
```
**Property Value**
[NodifyEditor](Nodify_NodifyEditor)
### HeaderBrush
Gets or sets the brush used for the background of the [HeaderedContentControl.Header](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.HeaderedContentControl#header) of this [GroupingNode](Nodify_GroupingNode).
```csharp
public Brush HeaderBrush { get; set; }
```
**Property Value**
[Brush](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Brush)
### MovementMode
Gets or sets the default movement mode which can be temporarily changed by holding the SwitchMovementModeModifierKey while dragging by the header.
```csharp
public GroupingMovementMode MovementMode { get; set; }
```
**Property Value**
[GroupingMovementMode](Nodify_GroupingMovementMode)
### ResizeCompletedCommand
Invoked when the [GroupingNode.ResizeCompleted](Nodify_GroupingNode#resizecompleted) event is not handled.
Parameter is the [ItemContainer.ActualSize](Nodify_ItemContainer#actualsize) of the container.
```csharp
public ICommand ResizeCompletedCommand { get; set; }
```
**Property Value**
[ICommand](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ICommand)
### ResizeStartedCommand
Invoked when the [GroupingNode.ResizeStarted](Nodify_GroupingNode#resizestarted) event is not handled.
Parameter is the [ItemContainer.ActualSize](Nodify_ItemContainer#actualsize) of the container.
```csharp
public ICommand ResizeStartedCommand { get; set; }
```
**Property Value**
[ICommand](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ICommand)
## Methods
### OnApplyTemplate()
```csharp
public override void OnApplyTemplate();
```
### ToggleContentSelection()
Toggles the selection of nodes inside this group.
If any contained nodes are selected, all will be unselected.
If none are selected, all will be selected.
```csharp
public void ToggleContentSelection();
```
## Events
### ResizeCompleted
Occurs when the node finished resizing.
```csharp
public event ResizeEventHandler ResizeCompleted;
```
**Event Type**
[ResizeEventHandler](Nodify_Events_ResizeEventHandler)
### ResizeStarted
Occurs when the node started resizing.
```csharp
public event ResizeEventHandler ResizeStarted;
```
**Event Type**
[ResizeEventHandler](Nodify_Events_ResizeEventHandler)

View File

@@ -0,0 +1,32 @@
# HotKeyControl Class
**Namespace:** Nodify
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [DispatcherObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Threading.DispatcherObject) → [DependencyObject](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.DependencyObject) → [Visual](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Media.Visual) → [UIElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.UIElement) → [FrameworkElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.FrameworkElement) → [Control](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Controls.Control) → [HotKeyControl](Nodify_HotKeyControl)
```csharp
public class HotKeyControl : Control
```
## Constructors
### HotKeyControl()
```csharp
public HotKeyControl();
```
## Properties
### Number
```csharp
public int Number { get; set; }
```
**Property Value**
[Int32](https://docs.microsoft.com/en-us/dotnet/api/System.Int32)

View File

@@ -0,0 +1,40 @@
# HotKeysDisplayMode Enum
**Namespace:** Nodify
**Assembly:** Nodify
**References:** [PendingConnection](Nodify_PendingConnection)
Specifies how hotkeys are displayed for a pending connection.
```csharp
public enum HotKeysDisplayMode
```
## Fields
### All
Display hotkeys for both mouse and keyboard.
```csharp
All = 2;
```
### Keyboard
Display hotkeys for keyboard only.
```csharp
Keyboard = 1;
```
### None
No hotkeys will be displayed for the pending connection.
```csharp
None = 0;
```

View File

@@ -0,0 +1,54 @@
# INodifyCanvasItem Interface
**Namespace:** Nodify
**Assembly:** Nodify
**Derived:** [ItemContainer](Nodify_ItemContainer), [DecoratorContainer](Nodify_DecoratorContainer)
**References:** [NodifyCanvas](Nodify_NodifyCanvas)
Interface for items inside a [NodifyCanvas](Nodify_NodifyCanvas).
```csharp
public interface INodifyCanvasItem
```
## Properties
### DesiredSize
The desired size of the item.
```csharp
public virtual Size DesiredSize { get; set; }
```
**Property Value**
[Size](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Size)
### Location
The location of the item.
```csharp
public virtual Point Location { get; set; }
```
**Property Value**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
## Methods
### Arrange(Rect)
```csharp
public virtual void Arrange(Rect rect);
```
**Parameters**
`rect` [Rect](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Rect)

View File

@@ -0,0 +1,24 @@
# AllGestures Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture) → [MultiGesture](Nodify_Interactivity_MultiGesture) → [AllGestures](Nodify_Interactivity_AllGestures)
```csharp
public sealed class AllGestures : MultiGesture
```
## Constructors
### AllGestures(InputGesture[])
```csharp
public AllGestures(InputGesture[] gestures);
```
**Parameters**
`gestures` [InputGesture[]](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture[])

View File

@@ -0,0 +1,24 @@
# AnyGesture Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture) → [MultiGesture](Nodify_Interactivity_MultiGesture) → [AnyGesture](Nodify_Interactivity_AnyGesture)
```csharp
public sealed class AnyGesture : MultiGesture
```
## Constructors
### AnyGesture(InputGesture[])
```csharp
public AnyGesture(InputGesture[] gestures);
```
**Parameters**
`gestures` [InputGesture[]](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture[])

View File

@@ -0,0 +1,12 @@
# ConnectionState Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [ConnectionState](Nodify_Interactivity_ConnectionState)
```csharp
public static class ConnectionState
```

View File

@@ -0,0 +1,48 @@
# ConnectionState.Disconnect Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<BaseConnection\>](Nodify_Interactivity_InputElementState_TElement_) → [ConnectionState.Disconnect](Nodify_Interactivity_ConnectionState_Disconnect)
**References:** [BaseConnection](Nodify_BaseConnection)
```csharp
public class Disconnect : InputElementState<BaseConnection>
```
## Constructors
### ConnectionState.Disconnect(BaseConnection)
```csharp
public Disconnect(BaseConnection connection);
```
**Parameters**
`connection` [BaseConnection](Nodify_BaseConnection)
## Methods
### OnMouseDown(MouseButtonEventArgs)
```csharp
protected override void OnMouseDown(MouseButtonEventArgs e);
```
**Parameters**
`e` [MouseButtonEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseButtonEventArgs)
### OnMouseUp(MouseButtonEventArgs)
```csharp
protected override void OnMouseUp(MouseButtonEventArgs e);
```
**Parameters**
`e` [MouseButtonEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseButtonEventArgs)

View File

@@ -0,0 +1,38 @@
# ConnectionState.Split Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<BaseConnection\>](Nodify_Interactivity_InputElementState_TElement_) → [ConnectionState.Split](Nodify_Interactivity_ConnectionState_Split)
**References:** [BaseConnection](Nodify_BaseConnection)
```csharp
public class Split : InputElementState<BaseConnection>
```
## Constructors
### ConnectionState.Split(BaseConnection)
```csharp
public Split(BaseConnection connection);
```
**Parameters**
`connection` [BaseConnection](Nodify_BaseConnection)
## Methods
### OnMouseDown(MouseButtonEventArgs)
```csharp
protected override void OnMouseDown(MouseButtonEventArgs e);
```
**Parameters**
`e` [MouseButtonEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseButtonEventArgs)

View File

@@ -0,0 +1,26 @@
# ConnectorState Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [ConnectorState](Nodify_Interactivity_ConnectorState)
```csharp
public static class ConnectorState
```
## Properties
### EnableToggledConnectingMode
Determines whether toggled connecting mode is enabled, allowing the user to start and end the interaction in two steps with the same input gesture.
```csharp
public static bool EnableToggledConnectingMode { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)

View File

@@ -0,0 +1,100 @@
# ConnectorState.Connecting Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<Connector\>](Nodify_Interactivity_InputElementState_TElement_) → [DragState\<Connector\>](Nodify_Interactivity_DragState_TElement_) → [ConnectorState.Connecting](Nodify_Interactivity_ConnectorState_Connecting)
**References:** [Connector](Nodify_Connector)
```csharp
public class Connecting : DragState<Connector>
```
## Constructors
### ConnectorState.Connecting(Connector)
```csharp
public Connecting(Connector connector);
```
**Parameters**
`connector` [Connector](Nodify_Connector)
## Properties
### CanCancel
```csharp
protected override bool CanCancel { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### HasContextMenu
```csharp
protected override bool HasContextMenu { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### IsToggle
```csharp
protected override bool IsToggle { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
## Methods
### OnBegin(InputEventArgs)
```csharp
protected override void OnBegin(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnCancel(InputEventArgs)
```csharp
protected override void OnCancel(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnEnd(InputEventArgs)
```csharp
protected override void OnEnd(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnMouseMove(MouseEventArgs)
```csharp
protected override void OnMouseMove(MouseEventArgs e);
```
**Parameters**
`e` [MouseEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseEventArgs)

View File

@@ -0,0 +1,38 @@
# ConnectorState.Default Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<Connector\>](Nodify_Interactivity_InputElementState_TElement_) → [ConnectorState.Default](Nodify_Interactivity_ConnectorState_Default)
**References:** [Connector](Nodify_Connector)
```csharp
public class Default : InputElementState<Connector>
```
## Constructors
### ConnectorState.Default(Connector)
```csharp
public Default(Connector connector);
```
**Parameters**
`connector` [Connector](Nodify_Connector)
## Methods
### OnMouseDown(MouseButtonEventArgs)
```csharp
protected override void OnMouseDown(MouseButtonEventArgs e);
```
**Parameters**
`e` [MouseButtonEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseButtonEventArgs)

View File

@@ -0,0 +1,58 @@
# ConnectorState.Disconnect Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<Connector\>](Nodify_Interactivity_InputElementState_TElement_) → [ConnectorState.Disconnect](Nodify_Interactivity_ConnectorState_Disconnect)
**References:** [Connector](Nodify_Connector)
```csharp
public class Disconnect : InputElementState<Connector>
```
## Constructors
### ConnectorState.Disconnect(Connector)
```csharp
public Disconnect(Connector connector);
```
**Parameters**
`connector` [Connector](Nodify_Connector)
## Methods
### OnKeyDown(KeyEventArgs)
```csharp
protected override void OnKeyDown(KeyEventArgs e);
```
**Parameters**
`e` [KeyEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.KeyEventArgs)
### OnMouseDown(MouseButtonEventArgs)
```csharp
protected override void OnMouseDown(MouseButtonEventArgs e);
```
**Parameters**
`e` [MouseButtonEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseButtonEventArgs)
### OnMouseUp(MouseButtonEventArgs)
```csharp
protected override void OnMouseUp(MouseButtonEventArgs e);
```
**Parameters**
`e` [MouseButtonEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseButtonEventArgs)

View File

@@ -0,0 +1,26 @@
# ContainerState Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [ContainerState](Nodify_Interactivity_ContainerState)
```csharp
public static class ContainerState
```
## Properties
### EnableToggledDraggingMode
Determines whether toggled dragging mode is enabled, allowing the user to start and end the interaction in two steps with the same input gesture.
```csharp
public static bool EnableToggledDraggingMode { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)

View File

@@ -0,0 +1,26 @@
# ContainerState.Default Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementStateStack\<ItemContainer\>](Nodify_Interactivity_InputElementStateStack_TElement_) → [ContainerState.Default](Nodify_Interactivity_ContainerState_Default)
**References:** [ItemContainer](Nodify_ItemContainer)
```csharp
public sealed class Default : InputElementStateStack<ItemContainer>
```
## Constructors
### ContainerState.Default(ItemContainer)
```csharp
public Default(ItemContainer container);
```
**Parameters**
`container` [ItemContainer](Nodify_ItemContainer)

View File

@@ -0,0 +1,224 @@
# DragState\<TElement\> Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<TElement\>](Nodify_Interactivity_InputElementState_TElement_) → [DragState\<TElement\>](Nodify_Interactivity_DragState_TElement_)
```csharp
public abstract class DragState<TElement> : InputElementState<TElement>
```
## Constructors
### DragState\<TElement\>(TElement, InputGesture)
```csharp
public DragState<TElement>(TElement element, InputGesture beginGesture);
```
**Parameters**
`element` [TElement](Nodify_Interactivity_DragState_TElement__TElement)
`beginGesture` [InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture)
### DragState\<TElement\>(TElement, InputGesture, InputGesture)
```csharp
public DragState<TElement>(TElement element, InputGesture beginGesture, InputGesture cancelGesture);
```
**Parameters**
`element` [TElement](Nodify_Interactivity_DragState_TElement__TElement)
`beginGesture` [InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture)
`cancelGesture` [InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture)
## Properties
### BeginGesture
```csharp
protected InputGesture BeginGesture { get; set; }
```
**Property Value**
[InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture)
### CanBegin
```csharp
protected virtual bool CanBegin { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### CanCancel
```csharp
protected virtual bool CanCancel { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### CancelGesture
```csharp
protected InputGesture CancelGesture { get; set; }
```
**Property Value**
[InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture)
### HasContextMenu
```csharp
protected virtual bool HasContextMenu { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### IsToggle
```csharp
protected virtual bool IsToggle { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### PositionElement
```csharp
protected IInputElement PositionElement { get; set; }
```
**Property Value**
[IInputElement](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.IInputElement)
## Methods
### CanCaptureInput(InputEventArgs)
```csharp
protected virtual bool CanCaptureInput(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### CaptureInput(InputEventArgs)
```csharp
protected virtual void CaptureInput(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### GetInitialPosition(InputEventArgs)
```csharp
protected virtual Point GetInitialPosition(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
**Returns**
[Point](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Point)
### IsInputCaptureLost(InputEventArgs)
```csharp
protected virtual bool IsInputCaptureLost(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### IsInputEventPressed(InputEventArgs)
```csharp
protected virtual bool IsInputEventPressed(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### IsInputEventReleased(InputEventArgs)
```csharp
protected virtual bool IsInputEventReleased(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### OnBegin(InputEventArgs)
```csharp
protected virtual void OnBegin(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnCancel(InputEventArgs)
```csharp
protected virtual void OnCancel(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnEnd(InputEventArgs)
```csharp
protected virtual void OnEnd(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)

View File

@@ -0,0 +1,132 @@
# EditorGestures Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EditorGestures](Nodify_Interactivity_EditorGestures)
**References:** [EditorGestures.ConnectionGestures](Nodify_Interactivity_EditorGestures_ConnectionGestures), [EditorGestures.ConnectorGestures](Nodify_Interactivity_EditorGestures_ConnectorGestures), [EditorGestures.GroupingNodeGestures](Nodify_Interactivity_EditorGestures_GroupingNodeGestures), [EditorGestures.ItemContainerGestures](Nodify_Interactivity_EditorGestures_ItemContainerGestures), [EditorGestures.MinimapGestures](Nodify_Interactivity_EditorGestures_MinimapGestures), [NodifyEditor](Nodify_NodifyEditor), [EditorGestures.NodifyEditorGestures](Nodify_Interactivity_EditorGestures_NodifyEditorGestures)
Gestures used by built-in controls inside the [NodifyEditor](Nodify_NodifyEditor).
```csharp
public class EditorGestures
```
## Constructors
### EditorGestures()
```csharp
public EditorGestures();
```
## Fields
### Mappings
```csharp
public static EditorGestures Mappings;
```
**Field Value**
[EditorGestures](Nodify_Interactivity_EditorGestures)
## Properties
### Connection
Gestures for the connection.
```csharp
public ConnectionGestures Connection { get; set; }
```
**Property Value**
[EditorGestures.ConnectionGestures](Nodify_Interactivity_EditorGestures_ConnectionGestures)
### Connector
Gestures for the connector.
```csharp
public ConnectorGestures Connector { get; set; }
```
**Property Value**
[EditorGestures.ConnectorGestures](Nodify_Interactivity_EditorGestures_ConnectorGestures)
### Editor
Gestures for the editor.
```csharp
public NodifyEditorGestures Editor { get; set; }
```
**Property Value**
[EditorGestures.NodifyEditorGestures](Nodify_Interactivity_EditorGestures_NodifyEditorGestures)
### GroupingNode
Gestures for the grouping node.
```csharp
public GroupingNodeGestures GroupingNode { get; set; }
```
**Property Value**
[EditorGestures.GroupingNodeGestures](Nodify_Interactivity_EditorGestures_GroupingNodeGestures)
### ItemContainer
Gestures for the item container.
```csharp
public ItemContainerGestures ItemContainer { get; set; }
```
**Property Value**
[EditorGestures.ItemContainerGestures](Nodify_Interactivity_EditorGestures_ItemContainerGestures)
### Minimap
Gestures for the minimap.
```csharp
public MinimapGestures Minimap { get; set; }
```
**Property Value**
[EditorGestures.MinimapGestures](Nodify_Interactivity_EditorGestures_MinimapGestures)
## Methods
### Apply(EditorGestures)
Copies from the specified gestures.
```csharp
public void Apply(EditorGestures gestures);
```
**Parameters**
`gestures` [EditorGestures](Nodify_Interactivity_EditorGestures): The gestures to copy.
### Unbind()
Unbinds all the gestures used by the editor and its controls.
```csharp
public void Unbind();
```

View File

@@ -0,0 +1,72 @@
# EditorGestures.ConnectionGestures Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EditorGestures.ConnectionGestures](Nodify_Interactivity_EditorGestures_ConnectionGestures)
**References:** [EditorGestures](Nodify_Interactivity_EditorGestures), [InputGestureRef](Nodify_Interactivity_InputGestureRef), [EditorGestures.SelectionGestures](Nodify_Interactivity_EditorGestures_SelectionGestures)
```csharp
public class ConnectionGestures
```
## Constructors
### EditorGestures.ConnectionGestures()
```csharp
public ConnectionGestures();
```
## Properties
### Disconnect
```csharp
public InputGestureRef Disconnect { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Selection
```csharp
public SelectionGestures Selection { get; set; }
```
**Property Value**
[EditorGestures.SelectionGestures](Nodify_Interactivity_EditorGestures_SelectionGestures)
### Split
```csharp
public InputGestureRef Split { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
## Methods
### Apply(EditorGestures.ConnectionGestures)
```csharp
public void Apply(EditorGestures.ConnectionGestures gestures);
```
**Parameters**
`gestures` [EditorGestures.ConnectionGestures](Nodify_Interactivity_EditorGestures_ConnectionGestures)
### Unbind()
```csharp
public void Unbind();
```

View File

@@ -0,0 +1,72 @@
# EditorGestures.ConnectorGestures Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EditorGestures.ConnectorGestures](Nodify_Interactivity_EditorGestures_ConnectorGestures)
**References:** [EditorGestures](Nodify_Interactivity_EditorGestures), [InputGestureRef](Nodify_Interactivity_InputGestureRef)
```csharp
public class ConnectorGestures
```
## Constructors
### EditorGestures.ConnectorGestures()
```csharp
public ConnectorGestures();
```
## Properties
### CancelAction
```csharp
public InputGestureRef CancelAction { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Connect
```csharp
public InputGestureRef Connect { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Disconnect
```csharp
public InputGestureRef Disconnect { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
## Methods
### Apply(EditorGestures.ConnectorGestures)
```csharp
public void Apply(EditorGestures.ConnectorGestures gestures);
```
**Parameters**
`gestures` [EditorGestures.ConnectorGestures](Nodify_Interactivity_EditorGestures_ConnectorGestures)
### Unbind()
```csharp
public void Unbind();
```

View File

@@ -0,0 +1,100 @@
# EditorGestures.DirectionalNavigationGestures Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EditorGestures.DirectionalNavigationGestures](Nodify_Interactivity_EditorGestures_DirectionalNavigationGestures)
**References:** [InputGestureRef](Nodify_Interactivity_InputGestureRef), [NodifyEditorGestures.KeyboardGestures](Nodify_Interactivity_NodifyEditorGestures_KeyboardGestures), [EditorGestures.MinimapGestures](Nodify_Interactivity_EditorGestures_MinimapGestures)
```csharp
public class DirectionalNavigationGestures
```
## Constructors
### EditorGestures.DirectionalNavigationGestures(ModifierKeys)
```csharp
public DirectionalNavigationGestures(ModifierKeys modifierKeys = 0);
```
**Parameters**
`modifierKeys` [ModifierKeys](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ModifierKeys)
### EditorGestures.DirectionalNavigationGestures(Key, ModifierKeys, Boolean)
```csharp
public DirectionalNavigationGestures(Key triggerKey, ModifierKeys modifierKeys = 0, bool repeated = false);
```
**Parameters**
`triggerKey` [Key](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.Key)
`modifierKeys` [ModifierKeys](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ModifierKeys)
`repeated` [Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
## Properties
### Down
```csharp
public InputGestureRef Down { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Left
```csharp
public InputGestureRef Left { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Right
```csharp
public InputGestureRef Right { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Up
```csharp
public InputGestureRef Up { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
## Methods
### Apply(EditorGestures.DirectionalNavigationGestures)
```csharp
public void Apply(EditorGestures.DirectionalNavigationGestures gestures);
```
**Parameters**
`gestures` [EditorGestures.DirectionalNavigationGestures](Nodify_Interactivity_EditorGestures_DirectionalNavigationGestures)
### Unbind()
```csharp
public void Unbind();
```

View File

@@ -0,0 +1,62 @@
# EditorGestures.GroupingNodeGestures Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EditorGestures.GroupingNodeGestures](Nodify_Interactivity_EditorGestures_GroupingNodeGestures)
**References:** [EditorGestures](Nodify_Interactivity_EditorGestures), [InputGestureRef](Nodify_Interactivity_InputGestureRef)
```csharp
public class GroupingNodeGestures
```
## Constructors
### EditorGestures.GroupingNodeGestures()
```csharp
public GroupingNodeGestures();
```
## Properties
### SwitchMovementMode
```csharp
public ModifierKeys SwitchMovementMode { get; set; }
```
**Property Value**
[ModifierKeys](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ModifierKeys)
### ToggleContentSelection
```csharp
public InputGestureRef ToggleContentSelection { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
## Methods
### Apply(EditorGestures.GroupingNodeGestures)
```csharp
public void Apply(EditorGestures.GroupingNodeGestures gestures);
```
**Parameters**
`gestures` [EditorGestures.GroupingNodeGestures](Nodify_Interactivity_EditorGestures_GroupingNodeGestures)
### Unbind()
```csharp
public void Unbind();
```

View File

@@ -0,0 +1,72 @@
# EditorGestures.ItemContainerGestures Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EditorGestures.ItemContainerGestures](Nodify_Interactivity_EditorGestures_ItemContainerGestures)
**References:** [EditorGestures](Nodify_Interactivity_EditorGestures), [InputGestureRef](Nodify_Interactivity_InputGestureRef), [EditorGestures.SelectionGestures](Nodify_Interactivity_EditorGestures_SelectionGestures)
```csharp
public class ItemContainerGestures
```
## Constructors
### EditorGestures.ItemContainerGestures()
```csharp
public ItemContainerGestures();
```
## Properties
### CancelAction
```csharp
public InputGestureRef CancelAction { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Drag
```csharp
public InputGestureRef Drag { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Selection
```csharp
public SelectionGestures Selection { get; set; }
```
**Property Value**
[EditorGestures.SelectionGestures](Nodify_Interactivity_EditorGestures_SelectionGestures)
## Methods
### Apply(EditorGestures.ItemContainerGestures)
```csharp
public void Apply(EditorGestures.ItemContainerGestures gestures);
```
**Parameters**
`gestures` [EditorGestures.ItemContainerGestures](Nodify_Interactivity_EditorGestures_ItemContainerGestures)
### Unbind()
```csharp
public void Unbind();
```

View File

@@ -0,0 +1,112 @@
# EditorGestures.MinimapGestures Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EditorGestures.MinimapGestures](Nodify_Interactivity_EditorGestures_MinimapGestures)
**References:** [EditorGestures.DirectionalNavigationGestures](Nodify_Interactivity_EditorGestures_DirectionalNavigationGestures), [EditorGestures](Nodify_Interactivity_EditorGestures), [InputGestureRef](Nodify_Interactivity_InputGestureRef)
```csharp
public class MinimapGestures
```
## Constructors
### EditorGestures.MinimapGestures()
```csharp
public MinimapGestures();
```
## Properties
### CancelAction
```csharp
public InputGestureRef CancelAction { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### DragViewport
```csharp
public InputGestureRef DragViewport { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Pan
```csharp
public DirectionalNavigationGestures Pan { get; set; }
```
**Property Value**
[EditorGestures.DirectionalNavigationGestures](Nodify_Interactivity_EditorGestures_DirectionalNavigationGestures)
### ResetViewport
```csharp
public InputGestureRef ResetViewport { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### ZoomIn
```csharp
public InputGestureRef ZoomIn { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### ZoomModifierKey
```csharp
public ModifierKeys ZoomModifierKey { get; set; }
```
**Property Value**
[ModifierKeys](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ModifierKeys)
### ZoomOut
```csharp
public InputGestureRef ZoomOut { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
## Methods
### Apply(EditorGestures.MinimapGestures)
```csharp
public void Apply(EditorGestures.MinimapGestures gestures);
```
**Parameters**
`gestures` [EditorGestures.MinimapGestures](Nodify_Interactivity_EditorGestures_MinimapGestures)
### Unbind()
```csharp
public void Unbind();
```

View File

@@ -0,0 +1,192 @@
# EditorGestures.NodifyEditorGestures Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EditorGestures.NodifyEditorGestures](Nodify_Interactivity_EditorGestures_NodifyEditorGestures)
**References:** [EditorGestures](Nodify_Interactivity_EditorGestures), [InputGestureRef](Nodify_Interactivity_InputGestureRef), [NodifyEditorGestures.KeyboardGestures](Nodify_Interactivity_NodifyEditorGestures_KeyboardGestures), [EditorGestures.SelectionGestures](Nodify_Interactivity_EditorGestures_SelectionGestures)
```csharp
public class NodifyEditorGestures
```
## Constructors
### EditorGestures.NodifyEditorGestures()
```csharp
public NodifyEditorGestures();
```
## Properties
### CancelAction
```csharp
public InputGestureRef CancelAction { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Cutting
```csharp
public InputGestureRef Cutting { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### FitToScreen
```csharp
public InputGestureRef FitToScreen { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Keyboard
```csharp
public KeyboardGestures Keyboard { get; set; }
```
**Property Value**
[NodifyEditorGestures.KeyboardGestures](Nodify_Interactivity_NodifyEditorGestures_KeyboardGestures)
### Pan
```csharp
public InputGestureRef Pan { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### PanHorizontalModifierKey
```csharp
public ModifierKeys PanHorizontalModifierKey { get; set; }
```
**Property Value**
[ModifierKeys](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ModifierKeys)
### PanVerticalModifierKey
```csharp
public ModifierKeys PanVerticalModifierKey { get; set; }
```
**Property Value**
[ModifierKeys](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ModifierKeys)
### PanWithMouseWheel
```csharp
public bool PanWithMouseWheel { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### PushItems
```csharp
public InputGestureRef PushItems { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### ResetViewport
```csharp
public InputGestureRef ResetViewport { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### SelectAll
```csharp
public InputGestureRef SelectAll { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Selection
```csharp
public SelectionGestures Selection { get; set; }
```
**Property Value**
[EditorGestures.SelectionGestures](Nodify_Interactivity_EditorGestures_SelectionGestures)
### ZoomIn
```csharp
public InputGestureRef ZoomIn { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### ZoomModifierKey
```csharp
public ModifierKeys ZoomModifierKey { get; set; }
```
**Property Value**
[ModifierKeys](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ModifierKeys)
### ZoomOut
```csharp
public InputGestureRef ZoomOut { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
## Methods
### Apply(EditorGestures.NodifyEditorGestures)
```csharp
public void Apply(EditorGestures.NodifyEditorGestures gestures);
```
**Parameters**
`gestures` [EditorGestures.NodifyEditorGestures](Nodify_Interactivity_EditorGestures_NodifyEditorGestures)
### Unbind()
```csharp
public void Unbind();
```

View File

@@ -0,0 +1,146 @@
# EditorGestures.SelectionGestures Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EditorGestures.SelectionGestures](Nodify_Interactivity_EditorGestures_SelectionGestures)
**References:** [EditorGestures.ConnectionGestures](Nodify_Interactivity_EditorGestures_ConnectionGestures), [InputGestureRef](Nodify_Interactivity_InputGestureRef), [EditorGestures.ItemContainerGestures](Nodify_Interactivity_EditorGestures_ItemContainerGestures), [EditorGestures.NodifyEditorGestures](Nodify_Interactivity_EditorGestures_NodifyEditorGestures)
```csharp
public class SelectionGestures
```
## Constructors
### EditorGestures.SelectionGestures(MouseAction, Boolean)
```csharp
public SelectionGestures(MouseAction mouseAction, bool ignoreModifierKeysOnRelease);
```
**Parameters**
`mouseAction` [MouseAction](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseAction)
`ignoreModifierKeysOnRelease` [Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### EditorGestures.SelectionGestures(MouseAction)
```csharp
public SelectionGestures(MouseAction mouseAction);
```
**Parameters**
`mouseAction` [MouseAction](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseAction)
### EditorGestures.SelectionGestures(Boolean)
```csharp
public SelectionGestures(bool ignoreModifierKeysOnRelease);
```
**Parameters**
`ignoreModifierKeysOnRelease` [Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### EditorGestures.SelectionGestures()
```csharp
public SelectionGestures();
```
## Fields
### None
```csharp
public static SelectionGestures None;
```
**Field Value**
[EditorGestures.SelectionGestures](Nodify_Interactivity_EditorGestures_SelectionGestures)
## Properties
### Append
```csharp
public InputGestureRef Append { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Cancel
```csharp
public InputGestureRef Cancel { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Invert
```csharp
public InputGestureRef Invert { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Remove
```csharp
public InputGestureRef Remove { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Replace
```csharp
public InputGestureRef Replace { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
### Select
```csharp
public InputGestureRef Select { get; set; }
```
**Property Value**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)
## Methods
### Apply(EditorGestures.SelectionGestures)
```csharp
public void Apply(EditorGestures.SelectionGestures gestures);
```
**Parameters**
`gestures` [EditorGestures.SelectionGestures](Nodify_Interactivity_EditorGestures_SelectionGestures)
### Unbind()
```csharp
public void Unbind();
```

View File

@@ -0,0 +1,146 @@
# EditorState Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [EditorState](Nodify_Interactivity_EditorState)
```csharp
public static class EditorState
```
## Properties
### AllowPanningWhileCutting
Gets or sets a value indicating whether panning is allowed while cutting connections in the editor.
```csharp
public static bool AllowPanningWhileCutting { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### AllowPanningWhilePushingItems
Gets or sets a value indicating whether panning is allowed while pushing items in the editor.
```csharp
public static bool AllowPanningWhilePushingItems { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### AllowPanningWhileSelecting
Gets or sets a value indicating whether panning is allowed while selecting items in the editor.
```csharp
public static bool AllowPanningWhileSelecting { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### AllowZoomingWhileCutting
Gets or sets a value indicating whether zooming is allowed while cutting connections in the editor.
```csharp
public static bool AllowZoomingWhileCutting { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### AllowZoomingWhilePanning
Gets or sets a value indicating whether zooming is allowed while panning the editor viewport.
```csharp
public static bool AllowZoomingWhilePanning { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### AllowZoomingWhilePushingItems
Gets or sets a value indicating whether zooming is allowed while pushing items in the editor.
```csharp
public static bool AllowZoomingWhilePushingItems { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### AllowZoomingWhileSelecting
Gets or sets a value indicating whether zooming is allowed while selecting items in the editor.
```csharp
public static bool AllowZoomingWhileSelecting { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### EnableToggledCuttingMode
Determines whether toggled cutting mode is enabled, allowing the user to start and end the interaction in two steps with the same input gesture.
```csharp
public static bool EnableToggledCuttingMode { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### EnableToggledPanningMode
Determines whether toggled panning mode is enabled, allowing the user to start and end the interaction in two steps with the same input gesture.
```csharp
public static bool EnableToggledPanningMode { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### EnableToggledPushingItemsMode
Determines whether toggled pushing items mode is enabled, allowing the user to start and end the interaction in two steps with the same input gesture.
```csharp
public static bool EnableToggledPushingItemsMode { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### EnableToggledSelectingMode
Determines whether toggled selecting mode is enabled, allowing the user to start and end the interaction in two steps with the same input gesture.
```csharp
public static bool EnableToggledSelectingMode { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)

View File

@@ -0,0 +1,110 @@
# EditorState.Cutting Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<NodifyEditor\>](Nodify_Interactivity_InputElementState_TElement_) → [DragState\<NodifyEditor\>](Nodify_Interactivity_DragState_TElement_) → [EditorState.Cutting](Nodify_Interactivity_EditorState_Cutting)
**References:** [NodifyEditor](Nodify_NodifyEditor)
```csharp
public class Cutting : DragState<NodifyEditor>
```
## Constructors
### EditorState.Cutting(NodifyEditor)
```csharp
public Cutting(NodifyEditor editor);
```
**Parameters**
`editor` [NodifyEditor](Nodify_NodifyEditor)
## Properties
### CanBegin
```csharp
protected override bool CanBegin { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### CanCancel
```csharp
protected override bool CanCancel { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### HasContextMenu
```csharp
protected override bool HasContextMenu { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### IsToggle
```csharp
protected override bool IsToggle { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
## Methods
### OnBegin(InputEventArgs)
```csharp
protected override void OnBegin(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnCancel(InputEventArgs)
```csharp
protected override void OnCancel(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnEnd(InputEventArgs)
```csharp
protected override void OnEnd(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnMouseMove(MouseEventArgs)
```csharp
protected override void OnMouseMove(MouseEventArgs e);
```
**Parameters**
`e` [MouseEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseEventArgs)

View File

@@ -0,0 +1,48 @@
# EditorState.KeyboardNavigation Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<NodifyEditor\>](Nodify_Interactivity_InputElementState_TElement_) → [EditorState.KeyboardNavigation](Nodify_Interactivity_EditorState_KeyboardNavigation)
**References:** [NodifyEditor](Nodify_NodifyEditor)
```csharp
public class KeyboardNavigation : InputElementState<NodifyEditor>
```
## Constructors
### EditorState.KeyboardNavigation(NodifyEditor)
```csharp
public KeyboardNavigation(NodifyEditor element);
```
**Parameters**
`element` [NodifyEditor](Nodify_NodifyEditor)
## Methods
### OnKeyDown(KeyEventArgs)
```csharp
protected override void OnKeyDown(KeyEventArgs e);
```
**Parameters**
`e` [KeyEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.KeyEventArgs)
### OnKeyUp(KeyEventArgs)
```csharp
protected override void OnKeyUp(KeyEventArgs e);
```
**Parameters**
`e` [KeyEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.KeyEventArgs)

View File

@@ -0,0 +1,110 @@
# EditorState.Panning Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<NodifyEditor\>](Nodify_Interactivity_InputElementState_TElement_) → [DragState\<NodifyEditor\>](Nodify_Interactivity_DragState_TElement_) → [EditorState.Panning](Nodify_Interactivity_EditorState_Panning)
**References:** [NodifyEditor](Nodify_NodifyEditor)
```csharp
public class Panning : DragState<NodifyEditor>
```
## Constructors
### EditorState.Panning(NodifyEditor)
```csharp
public Panning(NodifyEditor editor);
```
**Parameters**
`editor` [NodifyEditor](Nodify_NodifyEditor)
## Properties
### CanBegin
```csharp
protected override bool CanBegin { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### CanCancel
```csharp
protected override bool CanCancel { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### HasContextMenu
```csharp
protected override bool HasContextMenu { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### IsToggle
```csharp
protected override bool IsToggle { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
## Methods
### OnBegin(InputEventArgs)
```csharp
protected override void OnBegin(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnCancel(InputEventArgs)
```csharp
protected override void OnCancel(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnEnd(InputEventArgs)
```csharp
protected override void OnEnd(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnMouseMove(MouseEventArgs)
```csharp
protected override void OnMouseMove(MouseEventArgs e);
```
**Parameters**
`e` [MouseEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseEventArgs)

View File

@@ -0,0 +1,38 @@
# EditorState.PanningWithMouseWheel Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<NodifyEditor\>](Nodify_Interactivity_InputElementState_TElement_) → [EditorState.PanningWithMouseWheel](Nodify_Interactivity_EditorState_PanningWithMouseWheel)
**References:** [NodifyEditor](Nodify_NodifyEditor)
```csharp
public class PanningWithMouseWheel : InputElementState<NodifyEditor>
```
## Constructors
### EditorState.PanningWithMouseWheel(NodifyEditor)
```csharp
public PanningWithMouseWheel(NodifyEditor editor);
```
**Parameters**
`editor` [NodifyEditor](Nodify_NodifyEditor)
## Methods
### OnMouseWheel(MouseWheelEventArgs)
```csharp
protected override void OnMouseWheel(MouseWheelEventArgs e);
```
**Parameters**
`e` [MouseWheelEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseWheelEventArgs)

View File

@@ -0,0 +1,110 @@
# EditorState.PushingItems Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<NodifyEditor\>](Nodify_Interactivity_InputElementState_TElement_) → [DragState\<NodifyEditor\>](Nodify_Interactivity_DragState_TElement_) → [EditorState.PushingItems](Nodify_Interactivity_EditorState_PushingItems)
**References:** [NodifyEditor](Nodify_NodifyEditor)
```csharp
public class PushingItems : DragState<NodifyEditor>
```
## Constructors
### EditorState.PushingItems(NodifyEditor)
```csharp
public PushingItems(NodifyEditor editor);
```
**Parameters**
`editor` [NodifyEditor](Nodify_NodifyEditor)
## Properties
### CanBegin
```csharp
protected override bool CanBegin { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### CanCancel
```csharp
protected override bool CanCancel { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### HasContextMenu
```csharp
protected override bool HasContextMenu { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### IsToggle
```csharp
protected override bool IsToggle { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
## Methods
### OnBegin(InputEventArgs)
```csharp
protected override void OnBegin(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnCancel(InputEventArgs)
```csharp
protected override void OnCancel(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnEnd(InputEventArgs)
```csharp
protected override void OnEnd(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnMouseMove(MouseEventArgs)
```csharp
protected override void OnMouseMove(MouseEventArgs e);
```
**Parameters**
`e` [MouseEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseEventArgs)

View File

@@ -0,0 +1,110 @@
# EditorState.Selecting Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<NodifyEditor\>](Nodify_Interactivity_InputElementState_TElement_) → [DragState\<NodifyEditor\>](Nodify_Interactivity_DragState_TElement_) → [EditorState.Selecting](Nodify_Interactivity_EditorState_Selecting)
**References:** [NodifyEditor](Nodify_NodifyEditor)
```csharp
public class Selecting : DragState<NodifyEditor>
```
## Constructors
### EditorState.Selecting(NodifyEditor)
```csharp
public Selecting(NodifyEditor editor);
```
**Parameters**
`editor` [NodifyEditor](Nodify_NodifyEditor)
## Properties
### CanBegin
```csharp
protected override bool CanBegin { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### CanCancel
```csharp
protected override bool CanCancel { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### HasContextMenu
```csharp
protected override bool HasContextMenu { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### IsToggle
```csharp
protected override bool IsToggle { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
## Methods
### OnBegin(InputEventArgs)
```csharp
protected override void OnBegin(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnCancel(InputEventArgs)
```csharp
protected override void OnCancel(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnEnd(InputEventArgs)
```csharp
protected override void OnEnd(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnMouseMove(MouseEventArgs)
```csharp
protected override void OnMouseMove(MouseEventArgs e);
```
**Parameters**
`e` [MouseEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseEventArgs)

View File

@@ -0,0 +1,38 @@
# EditorState.Zooming Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<NodifyEditor\>](Nodify_Interactivity_InputElementState_TElement_) → [EditorState.Zooming](Nodify_Interactivity_EditorState_Zooming)
**References:** [NodifyEditor](Nodify_NodifyEditor)
```csharp
public class Zooming : InputElementState<NodifyEditor>
```
## Constructors
### EditorState.Zooming(NodifyEditor)
```csharp
public Zooming(NodifyEditor editor);
```
**Parameters**
`editor` [NodifyEditor](Nodify_NodifyEditor)
## Methods
### OnMouseWheel(MouseWheelEventArgs)
```csharp
protected override void OnMouseWheel(MouseWheelEventArgs e);
```
**Parameters**
`e` [MouseWheelEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseWheelEventArgs)

View File

@@ -0,0 +1,56 @@
# IInputHandler Interface
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Derived:** [InputElementState\<TElement\>](Nodify_Interactivity_InputElementState_TElement_), [InputElementState\<TElement\>](Nodify_Interactivity_InputElementState_TElement_), [InputElementStateStack\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement_), [InputElementStateStack\<TElement\>.IInputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_), [InputElementStateStack\<TElement\>.IInputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_), [InputElementState\<BaseConnection\>](Nodify_Interactivity_InputElementState_TElement_), [InputElementState\<Connector\>](Nodify_Interactivity_InputElementState_TElement_), [InputElementStateStack\<ItemContainer\>](Nodify_Interactivity_InputElementStateStack_TElement_), [InputElementState\<NodifyEditor\>](Nodify_Interactivity_InputElementState_TElement_), [InputElementStateStack\<TElement\>.IInputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_), [InputElementState\<TElement\>](Nodify_Interactivity_InputElementState_TElement_), [InputElementStateStack\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement_), [InputElementStateStack\<TElement\>.IInputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_), [InputElementState\<TElement\>](Nodify_Interactivity_InputElementState_TElement_), [InputElementStateStack\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement_), [InputProcessor.Shared\<TElement\>](Nodify_Interactivity_InputProcessor_Shared_TElement_), [InputElementState\<Minimap\>](Nodify_Interactivity_InputElementState_TElement_)
**References:** [InputProcessor](Nodify_Interactivity_InputProcessor)
Defines a contract for handling input events within an element or system.
```csharp
public interface IInputHandler
```
## Properties
### ProcessHandledEvents
Gets or sets a value indicating whether events that have been handled should be processed too.
```csharp
public virtual bool ProcessHandledEvents { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### RequiresInputCapture
Gets a value indicating whether the handler requires input capture to remain active.
```csharp
public virtual bool RequiresInputCapture { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
## Methods
### HandleEvent(InputEventArgs)
Handles a given input event, such as a mouse or keyboard interaction.
```csharp
public virtual void HandleEvent(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs): The [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs) representing the input event.

View File

@@ -0,0 +1,32 @@
# IKeyboardFocusTarget\<TElement\> Interface
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
```csharp
public interface IKeyboardFocusTarget<TElement>
```
## Properties
### Bounds
```csharp
public virtual Rect Bounds { get; set; }
```
**Property Value**
[Rect](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Rect)
### Element
```csharp
public virtual TElement Element { get; set; }
```
**Property Value**
[TElement](Nodify_Interactivity_IKeyboardFocusTarget_TElement__TElement)

View File

@@ -0,0 +1,88 @@
# IKeyboardNavigationLayer Interface
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Derived:** [ConnectionsMultiSelector](Nodify_ConnectionsMultiSelector), [NodifyEditor](Nodify_NodifyEditor), [DecoratorsControl](Nodify_DecoratorsControl)
**References:** [IKeyboardFocusTarget\<UIElement\>](Nodify_Interactivity_IKeyboardFocusTarget_TElement_), [IKeyboardNavigationLayerGroup](Nodify_Interactivity_IKeyboardNavigationLayerGroup), [KeyboardNavigationLayerId](Nodify_Interactivity_KeyboardNavigationLayerId), [NodifyEditor](Nodify_NodifyEditor)
Represents a layer of keyboard navigation that can handle focus movement and restoration.
```csharp
public interface IKeyboardNavigationLayer
```
## Properties
### Id
Gets the unique identifier for this keyboard navigation layer.
```csharp
public virtual KeyboardNavigationLayerId Id { get; set; }
```
**Property Value**
[KeyboardNavigationLayerId](Nodify_Interactivity_KeyboardNavigationLayerId)
### LastFocusedElement
Gets the last focused element within this layer, if any.
```csharp
public virtual IKeyboardFocusTarget<UIElement> LastFocusedElement { get; set; }
```
**Property Value**
[IKeyboardFocusTarget\<UIElement\>](Nodify_Interactivity_IKeyboardFocusTarget_TElement_)
## Methods
### OnActivated()
Called when the layer is activated, allowing for any necessary setup or focus management.
```csharp
public virtual void OnActivated();
```
### OnDeactivated()
Called when the layer is deactivated, allowing for any necessary cleanup or focus management.
```csharp
public virtual void OnDeactivated();
```
### TryMoveFocus(TraversalRequest)
Attempts to move focus within this layer based on the provided traversal request.
```csharp
public virtual bool TryMoveFocus(TraversalRequest request);
```
**Parameters**
`request` [TraversalRequest](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.TraversalRequest): The traversal request.
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean): Returns true if the focus was moved, false otherwise.
### TryRestoreFocus()
Attempts to restore focus to the last focused element within this layer.
```csharp
public virtual bool TryRestoreFocus();
```
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean): Returns true if the focus was restored, false otherwise.

View File

@@ -0,0 +1,120 @@
# IKeyboardNavigationLayerGroup Interface
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Implements:** [IReadOnlyCollection\<IKeyboardNavigationLayer\>](https://docs.microsoft.com/en-us/dotnet/api/System.Collections.Generic.IReadOnlyCollection-1)
**Derived:** [NodifyEditor](Nodify_NodifyEditor)
**References:** [IKeyboardNavigationLayer](Nodify_Interactivity_IKeyboardNavigationLayer), [KeyboardNavigationLayerId](Nodify_Interactivity_KeyboardNavigationLayerId)
Represents a group of keyboard navigation layers that can be activated and navigated through.
```csharp
public interface IKeyboardNavigationLayerGroup : IReadOnlyCollection<IKeyboardNavigationLayer>
```
## Properties
### ActiveNavigationLayer
The current active keyboard navigation layer in the group, if any.
```csharp
public virtual IKeyboardNavigationLayer ActiveNavigationLayer { get; set; }
```
**Property Value**
[IKeyboardNavigationLayer](Nodify_Interactivity_IKeyboardNavigationLayer)
## Methods
### ActivateNavigationLayer(KeyboardNavigationLayerId)
Activates the specified keyboard navigation layer, making it the active layer for focus management.
```csharp
public virtual bool ActivateNavigationLayer(KeyboardNavigationLayerId layerId);
```
**Parameters**
`layerId` [KeyboardNavigationLayerId](Nodify_Interactivity_KeyboardNavigationLayerId): The navigation layer id to activate.
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean): Returns true if the navigation layer was activated, false otherwise.
### ActivateNextNavigationLayer()
Activates the next keyboard navigation layer in the group, allowing focus to be restored to the last focused element in that layer.
```csharp
public virtual bool ActivateNextNavigationLayer();
```
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean): Returns true if the navigation layer was activated, false otherwise.
### ActivatePreviousNavigationLayer()
Activates the previous keyboard navigation layer in the group, allowing focus to be restored to the last focused element in that layer.
```csharp
public virtual bool ActivatePreviousNavigationLayer();
```
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean): Returns true if the navigation layer was activated, false otherwise.
### RegisterNavigationLayer(IKeyboardNavigationLayer)
Registers a new keyboard navigation layer to the group, allowing it to handle focus movement and restoration.
```csharp
public virtual bool RegisterNavigationLayer(IKeyboardNavigationLayer layer);
```
**Parameters**
`layer` [IKeyboardNavigationLayer](Nodify_Interactivity_IKeyboardNavigationLayer): The navigation layer.
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### RemoveNavigationLayer(KeyboardNavigationLayerId)
Removes the specified keyboard navigation layer from the group.
```csharp
public virtual bool RemoveNavigationLayer(KeyboardNavigationLayerId layerId);
```
**Parameters**
`layerId` [KeyboardNavigationLayerId](Nodify_Interactivity_KeyboardNavigationLayerId): The navigation layer id.
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean): Returns true if the layer was removed, false otherwise.
## Events
### ActiveNavigationLayerChanged
Event that is raised when the active keyboard navigation layer changes.
```csharp
public virtual event Action<KeyboardNavigationLayerId> ActiveNavigationLayerChanged;
```
**Event Type**
[Action\<KeyboardNavigationLayerId\>](https://docs.microsoft.com/en-us/dotnet/api/System.Action-1)

View File

@@ -0,0 +1,104 @@
# InputElementStateStack\<TElement\> Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementStateStack\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement_)
**Implements:** [IInputHandler](Nodify_Interactivity_IInputHandler)
**References:** [InputElementStateStack\<TElement\>.IInputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_)
```csharp
public class InputElementStateStack<TElement> : IInputHandler
```
## Constructors
### InputElementStateStack\<TElement\>(TElement)
```csharp
public InputElementStateStack<TElement>(TElement element);
```
**Parameters**
`element` [TElement](Nodify_Interactivity_InputElementStateStack_TElement__TElement)
## Properties
### Element
```csharp
protected TElement Element { get; set; }
```
**Property Value**
[TElement](Nodify_Interactivity_InputElementStateStack_TElement__TElement)
### ProcessHandledEvents
```csharp
public virtual bool ProcessHandledEvents { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### RequiresInputCapture
```csharp
public virtual bool RequiresInputCapture { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### State
```csharp
public IInputElementState<TElement> State { get; set; }
```
**Property Value**
[InputElementStateStack\<TElement\>.IInputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_)
## Methods
### HandleEvent(InputEventArgs)
```csharp
public virtual void HandleEvent(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### PopAllStates()
```csharp
public void PopAllStates();
```
### PopState()
```csharp
public void PopState();
```
### PushState(InputElementStateStack\<TElement\>.IInputElementState\<TElement\>)
```csharp
public void PushState(IInputElementState<TElement> newState);
```
**Parameters**
`newState` [InputElementStateStack\<TElement\>.IInputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_)

View File

@@ -0,0 +1,110 @@
# InputElementStateStack\<TElement\>.DragState\<TElement\> Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<TElement\>](Nodify_Interactivity_InputElementState_TElement_) → [DragState\<TElement\>](Nodify_Interactivity_DragState_TElement_) → [InputElementStateStack\<TElement\>.DragState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__DragState_TElement_)
**Implements:** [InputElementStateStack\<TElement\>.IInputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_)
**References:** [InputElementStateStack\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement_)
```csharp
public abstract class DragState<TElement> : DragState<TElement>, IInputElementState<TElement>
```
## Constructors
### InputElementStateStack\<TElement\>.DragState\<TElement\>(InputElementStateStack\<TElement\>, InputGesture, InputGesture)
```csharp
public DragState<TElement>(InputElementStateStack<TElement> stack, InputGesture exitGesture, InputGesture cancelGesture);
```
**Parameters**
`stack` [InputElementStateStack\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement_)
`exitGesture` [InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture)
`cancelGesture` [InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture)
### InputElementStateStack\<TElement\>.DragState\<TElement\>(InputElementStateStack\<TElement\>, InputGesture)
```csharp
public DragState<TElement>(InputElementStateStack<TElement> stack, InputGesture exitGesture);
```
**Parameters**
`stack` [InputElementStateStack\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement_)
`exitGesture` [InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture)
## Properties
### Stack
```csharp
public InputElementStateStack<TElement> Stack { get; set; }
```
**Property Value**
[InputElementStateStack\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement_)
## Methods
### Enter(InputElementStateStack\<TElement\>.IInputElementState\<TElement\>)
```csharp
public virtual void Enter(InputElementStateStack<TElement>.IInputElementState<TElement> from);
```
**Parameters**
`from` [InputElementStateStack\<TElement\>.IInputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_)
### Exit()
```csharp
public virtual void Exit();
```
### OnCancel(InputEventArgs)
```csharp
protected override void OnCancel(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnEnd(InputEventArgs)
```csharp
protected override void OnEnd(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### PopState()
```csharp
public void PopState();
```
### PushState(InputElementStateStack\<TElement\>.IInputElementState\<TElement\>)
```csharp
public void PushState(InputElementStateStack<TElement>.IInputElementState<TElement> newState);
```
**Parameters**
`newState` [InputElementStateStack\<TElement\>.IInputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_)

View File

@@ -0,0 +1,30 @@
# InputElementStateStack\<TElement\>.IInputElementState\<TElement\> Interface
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Implements:** [IInputHandler](Nodify_Interactivity_IInputHandler)
```csharp
public interface IInputElementState<TElement> : IInputHandler
```
## Methods
### Enter(InputElementStateStack\<TElement\>.IInputElementState\<TElement\>)
```csharp
public virtual void Enter(InputElementStateStack<TElement>.IInputElementState<TElement> from);
```
**Parameters**
`from` [InputElementStateStack\<TElement\>.IInputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_)
### Exit()
```csharp
public virtual void Exit();
```

View File

@@ -0,0 +1,74 @@
# InputElementStateStack\<TElement\>.InputElementState\<TElement\> Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<TElement\>](Nodify_Interactivity_InputElementState_TElement_) → [InputElementStateStack\<TElement\>.InputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__InputElementState_TElement_)
**Implements:** [InputElementStateStack\<TElement\>.IInputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_)
**References:** [InputElementStateStack\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement_)
```csharp
public abstract class InputElementState<TElement> : InputElementState<TElement>, IInputElementState<TElement>
```
## Constructors
### InputElementStateStack\<TElement\>.InputElementState\<TElement\>(InputElementStateStack\<TElement\>)
```csharp
public InputElementState<TElement>(InputElementStateStack<TElement> stack);
```
**Parameters**
`stack` [InputElementStateStack\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement_)
## Properties
### Stack
```csharp
protected InputElementStateStack<TElement> Stack { get; set; }
```
**Property Value**
[InputElementStateStack\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement_)
## Methods
### Enter(InputElementStateStack\<TElement\>.IInputElementState\<TElement\>)
```csharp
public virtual void Enter(InputElementStateStack<TElement>.IInputElementState<TElement> from);
```
**Parameters**
`from` [InputElementStateStack\<TElement\>.IInputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_)
### Exit()
```csharp
public virtual void Exit();
```
### PopState()
```csharp
public void PopState();
```
### PushState(InputElementStateStack\<TElement\>.IInputElementState\<TElement\>)
```csharp
public void PushState(InputElementStateStack<TElement>.IInputElementState<TElement> newState);
```
**Parameters**
`newState` [InputElementStateStack\<TElement\>.IInputElementState\<TElement\>](Nodify_Interactivity_InputElementStateStack_TElement__IInputElementState_TElement_)

View File

@@ -0,0 +1,150 @@
# InputElementState\<TElement\> Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<TElement\>](Nodify_Interactivity_InputElementState_TElement_)
**Implements:** [IInputHandler](Nodify_Interactivity_IInputHandler)
```csharp
public abstract class InputElementState<TElement> : IInputHandler
```
## Constructors
### InputElementState\<TElement\>(TElement)
```csharp
protected InputElementState<TElement>(TElement element);
```
**Parameters**
`element` [TElement](Nodify_Interactivity_InputElementState_TElement__TElement)
## Properties
### Element
```csharp
protected TElement Element { get; set; }
```
**Property Value**
[TElement](Nodify_Interactivity_InputElementState_TElement__TElement)
### ProcessHandledEvents
```csharp
public virtual bool ProcessHandledEvents { get; protected set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### RequiresInputCapture
```csharp
public virtual bool RequiresInputCapture { get; protected set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
## Methods
### HandleEvent(InputEventArgs)
```csharp
public virtual void HandleEvent(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnEvent(InputEventArgs)
```csharp
protected virtual void OnEvent(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnKeyDown(KeyEventArgs)
```csharp
protected virtual void OnKeyDown(KeyEventArgs e);
```
**Parameters**
`e` [KeyEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.KeyEventArgs)
### OnKeyUp(KeyEventArgs)
```csharp
protected virtual void OnKeyUp(KeyEventArgs e);
```
**Parameters**
`e` [KeyEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.KeyEventArgs)
### OnLostMouseCapture(MouseEventArgs)
```csharp
protected virtual void OnLostMouseCapture(MouseEventArgs e);
```
**Parameters**
`e` [MouseEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseEventArgs)
### OnMouseDown(MouseButtonEventArgs)
```csharp
protected virtual void OnMouseDown(MouseButtonEventArgs e);
```
**Parameters**
`e` [MouseButtonEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseButtonEventArgs)
### OnMouseMove(MouseEventArgs)
```csharp
protected virtual void OnMouseMove(MouseEventArgs e);
```
**Parameters**
`e` [MouseEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseEventArgs)
### OnMouseUp(MouseButtonEventArgs)
```csharp
protected virtual void OnMouseUp(MouseButtonEventArgs e);
```
**Parameters**
`e` [MouseButtonEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseButtonEventArgs)
### OnMouseWheel(MouseWheelEventArgs)
```csharp
protected virtual void OnMouseWheel(MouseWheelEventArgs e);
```
**Parameters**
`e` [MouseWheelEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseWheelEventArgs)

View File

@@ -0,0 +1,57 @@
# InputGestureRef Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture) → [InputGestureRef](Nodify_Interactivity_InputGestureRef)
**References:** [EditorGestures.ConnectionGestures](Nodify_Interactivity_EditorGestures_ConnectionGestures), [EditorGestures.ConnectorGestures](Nodify_Interactivity_EditorGestures_ConnectorGestures), [EditorGestures.DirectionalNavigationGestures](Nodify_Interactivity_EditorGestures_DirectionalNavigationGestures), [EditorCommands](Nodify_EditorCommands), [EditorGestures.GroupingNodeGestures](Nodify_Interactivity_EditorGestures_GroupingNodeGestures), [InputGestureRefExtensions](Nodify_Interactivity_InputGestureRefExtensions), [EditorGestures.ItemContainerGestures](Nodify_Interactivity_EditorGestures_ItemContainerGestures), [NodifyEditorGestures.KeyboardGestures](Nodify_Interactivity_NodifyEditorGestures_KeyboardGestures), [EditorGestures.MinimapGestures](Nodify_Interactivity_EditorGestures_MinimapGestures), [EditorGestures.NodifyEditorGestures](Nodify_Interactivity_EditorGestures_NodifyEditorGestures), [EditorGestures.SelectionGestures](Nodify_Interactivity_EditorGestures_SelectionGestures)
An input gesture that allows changing its logic at runtime without changing its reference.
Useful for classes that capture the object reference without the posibility of updating it. (e.g. [EditorCommands](Nodify_EditorCommands))
```csharp
public sealed class InputGestureRef : InputGesture
```
## Properties
### Value
The referenced gesture.
```csharp
public InputGesture Value { get; set; }
```
**Property Value**
[InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture)
## Methods
### Matches(Object, InputEventArgs)
```csharp
public override bool Matches(object targetElement, InputEventArgs inputEventArgs);
```
**Parameters**
`targetElement` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
`inputEventArgs` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### Unbind()
Unbinds the current gesture.
```csharp
public void Unbind();
```

View File

@@ -0,0 +1,34 @@
# InputGestureRefExtensions Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputGestureRefExtensions](Nodify_Interactivity_InputGestureRefExtensions)
**References:** [InputGestureRef](Nodify_Interactivity_InputGestureRef)
Extension methods for the [InputGestureRef](Nodify_Interactivity_InputGestureRef) class.
```csharp
public static class InputGestureRefExtensions
```
## Methods
### AsRef(InputGesture)
Creates a new [InputGestureRef](Nodify_Interactivity_InputGestureRef) from the specified gesture.
```csharp
public static InputGestureRef AsRef(InputGesture gesture);
```
**Parameters**
`gesture` [InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture)
**Returns**
[InputGestureRef](Nodify_Interactivity_InputGestureRef)

View File

@@ -0,0 +1,80 @@
# InputProcessor Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputProcessor](Nodify_Interactivity_InputProcessor)
**Derived:** [InputProcessor.Shared\<TElement\>](Nodify_Interactivity_InputProcessor_Shared_TElement_)
**References:** [Connector](Nodify_Connector), [IInputHandler](Nodify_Interactivity_IInputHandler), [InputProcessorExtensions](Nodify_Interactivity_InputProcessorExtensions), [ItemContainer](Nodify_ItemContainer), [Minimap](Nodify_Minimap), [NodifyEditor](Nodify_NodifyEditor)
Processes input events and delegates them to registered handlers.
```csharp
public class InputProcessor
```
## Constructors
### InputProcessor()
```csharp
public InputProcessor();
```
## Properties
### RequiresInputCapture
Gets a value indicating whether the processor has ongoing interactions that require input capture to remain active.
```csharp
public virtual bool RequiresInputCapture { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
## Methods
### AddHandler(IInputHandler)
Adds an input handler to the processor.
```csharp
public void AddHandler(IInputHandler handler);
```
**Parameters**
`handler` [IInputHandler](Nodify_Interactivity_IInputHandler): The input handler to add.
### Clear()
Clears all registered handlers.
```csharp
public void Clear();
```
### ProcessEvent(InputEventArgs)
Processes an input event and delegates it to the registered handlers.
```csharp
public void ProcessEvent(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs): The input event arguments to process.
### RemoveHandlers()
```csharp
public void RemoveHandlers<T>();
```

View File

@@ -0,0 +1,30 @@
# InputProcessorExtensions Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputProcessorExtensions](Nodify_Interactivity_InputProcessorExtensions)
**References:** [InputProcessor](Nodify_Interactivity_InputProcessor)
Provides extension methods for the [InputProcessor](Nodify_Interactivity_InputProcessor) class.
```csharp
public static class InputProcessorExtensions
```
## Methods
### AddSharedHandlers(InputProcessor, TElement)
```csharp
public static void AddSharedHandlers<TElement>(InputProcessor inputProcessor, TElement instance);
```
**Parameters**
`inputProcessor` [InputProcessor](Nodify_Interactivity_InputProcessor)
`instance` [TElement](Nodify_Interactivity_InputProcessorExtensions_TElement)

View File

@@ -0,0 +1,70 @@
# InputProcessor.Shared\<TElement\> Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputProcessor](Nodify_Interactivity_InputProcessor) → [InputProcessor.Shared\<TElement\>](Nodify_Interactivity_InputProcessor_Shared_TElement_)
**Implements:** [IInputHandler](Nodify_Interactivity_IInputHandler)
```csharp
public sealed class Shared<TElement> : InputProcessor, IInputHandler
```
## Constructors
### InputProcessor.Shared\<TElement\>(TElement)
```csharp
public Shared<TElement>(TElement element);
```
**Parameters**
`element` [TElement](Nodify_Interactivity_Shared_TElement__TElement)
## Methods
### ClearHandlerFactories()
```csharp
public static void ClearHandlerFactories();
```
### HandleEvent(InputEventArgs)
```csharp
public virtual void HandleEvent(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### RegisterHandlerFactory(Func\<TElement, THandler\>)
```csharp
public static void RegisterHandlerFactory<THandler>(Func<TElement, THandler> factory);
```
**Parameters**
`factory` [Func\<TElement, THandler\>](https://docs.microsoft.com/en-us/dotnet/api/System.Func-2)
### RemoveHandlerFactory()
```csharp
public static void RemoveHandlerFactory<THandler>();
```
### ReplaceHandlerFactory(Func\<TElement, THandler\>)
```csharp
public static void ReplaceHandlerFactory<THandler>(Func<TElement, THandler> factory);
```
**Parameters**
`factory` [Func\<TElement, THandler\>](https://docs.microsoft.com/en-us/dotnet/api/System.Func-2)

View File

@@ -0,0 +1,107 @@
# KeyComboGesture Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture) → [KeyGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.KeyGesture) → [KeyComboGesture](Nodify_Interactivity_KeyComboGesture)
Represents a keyboard gesture that requires a trigger key to be held down
before pressing a combo key. For example, press and hold Space, then press Left arrow.
```csharp
public class KeyComboGesture : KeyGesture
```
## Constructors
### KeyComboGesture(Key, Key)
Initializes a new instance of the [KeyComboGesture](Nodify_Interactivity_KeyComboGesture) class with the specified trigger key,
combo key, modifiers, and display string.
```csharp
public KeyComboGesture(Key triggerKey, Key comboKey);
```
**Parameters**
`triggerKey` [Key](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.Key): The key that must be pressed first.
`comboKey` [Key](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.Key): The combo key pressed while the trigger key is held.
### KeyComboGesture(Key, Key, ModifierKeys)
```csharp
public KeyComboGesture(Key triggerKey, Key comboKey, ModifierKeys modifiers);
```
**Parameters**
`triggerKey` [Key](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.Key)
`comboKey` [Key](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.Key)
`modifiers` [ModifierKeys](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ModifierKeys)
### KeyComboGesture(Key, Key, ModifierKeys, String)
```csharp
public KeyComboGesture(Key triggerKey, Key comboKey, ModifierKeys modifiers, string displayString);
```
**Parameters**
`triggerKey` [Key](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.Key)
`comboKey` [Key](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.Key)
`modifiers` [ModifierKeys](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ModifierKeys)
`displayString` [String](https://docs.microsoft.com/en-us/dotnet/api/System.String)
## Properties
### AllowRepeatingComboKey
Gets or sets a value indicating whether the combo key can be repeatedly triggered
without releasing the trigger key.
```csharp
public bool AllowRepeatingComboKey { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### TriggerKey
Gets or sets the key that must be pressed first to activate this combo gesture.
```csharp
public Key TriggerKey { get; set; }
```
**Property Value**
[Key](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.Key)
## Methods
### Matches(Object, InputEventArgs)
```csharp
public override bool Matches(object targetElement, InputEventArgs inputEventArgs);
```
**Parameters**
`targetElement` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
`inputEventArgs` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)

View File

@@ -0,0 +1,56 @@
# KeyboardNavigationLayerId Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [KeyboardNavigationLayerId](Nodify_Interactivity_KeyboardNavigationLayerId)
**References:** [ConnectionsMultiSelector](Nodify_ConnectionsMultiSelector), [DecoratorsControl](Nodify_DecoratorsControl), [IKeyboardNavigationLayer](Nodify_Interactivity_IKeyboardNavigationLayer), [IKeyboardNavigationLayerGroup](Nodify_Interactivity_IKeyboardNavigationLayerGroup), [NodifyEditor](Nodify_NodifyEditor)
Represents a unique identifier for a keyboard navigation layer.
```csharp
public class KeyboardNavigationLayerId
```
## Constructors
### KeyboardNavigationLayerId()
```csharp
public KeyboardNavigationLayerId();
```
## Fields
### Connections
```csharp
public static KeyboardNavigationLayerId Connections;
```
**Field Value**
[KeyboardNavigationLayerId](Nodify_Interactivity_KeyboardNavigationLayerId)
### Decorators
```csharp
public static KeyboardNavigationLayerId Decorators;
```
**Field Value**
[KeyboardNavigationLayerId](Nodify_Interactivity_KeyboardNavigationLayerId)
### Nodes
```csharp
public static KeyboardNavigationLayerId Nodes;
```
**Field Value**
[KeyboardNavigationLayerId](Nodify_Interactivity_KeyboardNavigationLayerId)

View File

@@ -0,0 +1,26 @@
# MinimapState Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [MinimapState](Nodify_Interactivity_MinimapState)
```csharp
public static class MinimapState
```
## Properties
### EnableToggledPanningMode
Determines whether toggled panning mode is enabled, allowing the user to start and end the interaction in two steps with the same input gesture.
```csharp
public static bool EnableToggledPanningMode { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)

View File

@@ -0,0 +1,38 @@
# MinimapState.KeyboardNavigation Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<Minimap\>](Nodify_Interactivity_InputElementState_TElement_) → [MinimapState.KeyboardNavigation](Nodify_Interactivity_MinimapState_KeyboardNavigation)
**References:** [Minimap](Nodify_Minimap)
```csharp
public class KeyboardNavigation : InputElementState<Minimap>
```
## Constructors
### MinimapState.KeyboardNavigation(Minimap)
```csharp
public KeyboardNavigation(Minimap element);
```
**Parameters**
`element` [Minimap](Nodify_Minimap)
## Methods
### OnKeyDown(KeyEventArgs)
```csharp
protected override void OnKeyDown(KeyEventArgs e);
```
**Parameters**
`e` [KeyEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.KeyEventArgs)

View File

@@ -0,0 +1,100 @@
# MinimapState.Panning Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<Minimap\>](Nodify_Interactivity_InputElementState_TElement_) → [DragState\<Minimap\>](Nodify_Interactivity_DragState_TElement_) → [MinimapState.Panning](Nodify_Interactivity_MinimapState_Panning)
**References:** [Minimap](Nodify_Minimap)
```csharp
public class Panning : DragState<Minimap>
```
## Constructors
### MinimapState.Panning(Minimap)
```csharp
public Panning(Minimap minimap);
```
**Parameters**
`minimap` [Minimap](Nodify_Minimap)
## Properties
### CanBegin
```csharp
protected override bool CanBegin { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### CanCancel
```csharp
protected override bool CanCancel { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### IsToggle
```csharp
protected override bool IsToggle { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
## Methods
### OnBegin(InputEventArgs)
```csharp
protected override void OnBegin(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnCancel(InputEventArgs)
```csharp
protected override void OnCancel(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnEnd(InputEventArgs)
```csharp
protected override void OnEnd(InputEventArgs e);
```
**Parameters**
`e` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
### OnMouseMove(MouseEventArgs)
```csharp
protected override void OnMouseMove(MouseEventArgs e);
```
**Parameters**
`e` [MouseEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseEventArgs)

View File

@@ -0,0 +1,48 @@
# MinimapState.Zooming Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputElementState\<Minimap\>](Nodify_Interactivity_InputElementState_TElement_) → [MinimapState.Zooming](Nodify_Interactivity_MinimapState_Zooming)
**References:** [Minimap](Nodify_Minimap)
```csharp
public class Zooming : InputElementState<Minimap>
```
## Constructors
### MinimapState.Zooming(Minimap)
```csharp
public Zooming(Minimap minimap);
```
**Parameters**
`minimap` [Minimap](Nodify_Minimap)
## Methods
### OnKeyDown(KeyEventArgs)
```csharp
protected override void OnKeyDown(KeyEventArgs e);
```
**Parameters**
`e` [KeyEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.KeyEventArgs)
### OnMouseWheel(MouseWheelEventArgs)
```csharp
protected override void OnMouseWheel(MouseWheelEventArgs e);
```
**Parameters**
`e` [MouseWheelEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseWheelEventArgs)

View File

@@ -0,0 +1,134 @@
# MouseGesture Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture) → [MouseGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseGesture) → [MouseGesture](Nodify_Interactivity_MouseGesture)
Represents a mouse gesture that optionally includes a specific key press as part of the gesture.
```csharp
public sealed class MouseGesture : MouseGesture
```
## Constructors
### MouseGesture(MouseAction, ModifierKeys, Key)
Initializes a new instance of the [MouseGesture](Nodify_Interactivity_MouseGesture) class with the specified mouse action, modifier keys, and a specific key.
```csharp
public MouseGesture(MouseAction action, ModifierKeys modifiers, Key key);
```
**Parameters**
`action` [MouseAction](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseAction): The action associated with this gesture.
`modifiers` [ModifierKeys](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ModifierKeys): The modifiers associated with this gesture.
`key` [Key](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.Key): The key required to match the gesture.
### MouseGesture(MouseAction, Key)
Initializes a new instance of the [MouseGesture](Nodify_Interactivity_MouseGesture) class with the specified mouse action and key.
```csharp
public MouseGesture(MouseAction action, Key key);
```
**Parameters**
`action` [MouseAction](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseAction): The action associated with this gesture.
`key` [Key](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.Key): The key required to match the gesture.
### MouseGesture(MouseAction, ModifierKeys)
Initializes a new instance of the [MouseGesture](Nodify_Interactivity_MouseGesture) class with the specified mouse action and modifier keys.
```csharp
public MouseGesture(MouseAction action, ModifierKeys modifiers);
```
**Parameters**
`action` [MouseAction](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseAction): The action associated with this gesture.
`modifiers` [ModifierKeys](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ModifierKeys): The modifiers required to match the gesture.
### MouseGesture(MouseAction, ModifierKeys, Boolean)
```csharp
public MouseGesture(MouseAction action, ModifierKeys modifiers, bool ignoreModifierKeysOnRelease);
```
**Parameters**
`action` [MouseAction](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseAction)
`modifiers` [ModifierKeys](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.ModifierKeys)
`ignoreModifierKeysOnRelease` [Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### MouseGesture(MouseAction)
```csharp
public MouseGesture(MouseAction action);
```
**Parameters**
`action` [MouseAction](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.MouseAction)
### MouseGesture()
```csharp
public MouseGesture();
```
## Properties
### IgnoreModifierKeysOnRelease
Whether to ignore modifier keys when releasing the mouse button.
```csharp
public bool IgnoreModifierKeysOnRelease { get; set; }
```
**Property Value**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)
### Key
Gets or sets the key that must be pressed to match this gesture.
```csharp
public Key Key { get; set; }
```
**Property Value**
[Key](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.Key)
## Methods
### Matches(Object, InputEventArgs)
```csharp
public override bool Matches(object targetElement, InputEventArgs inputEventArgs);
```
**Parameters**
`targetElement` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
`inputEventArgs` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)

View File

@@ -0,0 +1,64 @@
# MultiGesture Class
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**Inheritance:** [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object) → [InputGesture](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture) → [MultiGesture](Nodify_Interactivity_MultiGesture)
**Derived:** [AllGestures](Nodify_Interactivity_AllGestures), [AnyGesture](Nodify_Interactivity_AnyGesture)
**References:** [MultiGesture.Match](Nodify_Interactivity_MultiGesture_Match)
Combines multiple input gestures.
```csharp
public class MultiGesture : InputGesture
```
## Constructors
### MultiGesture(MultiGesture.Match, InputGesture[])
Constructs an instance of a [MultiGesture](Nodify_Interactivity_MultiGesture).
```csharp
public MultiGesture(Match match, InputGesture[] gestures);
```
**Parameters**
`match` [MultiGesture.Match](Nodify_Interactivity_MultiGesture_Match): The matching strategy.
`gestures` [InputGesture[]](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputGesture[]): The input gestures.
## Fields
### None
```csharp
public static MultiGesture None;
```
**Field Value**
[MultiGesture](Nodify_Interactivity_MultiGesture)
## Methods
### Matches(Object, InputEventArgs)
```csharp
public override bool Matches(object targetElement, InputEventArgs inputEventArgs);
```
**Parameters**
`targetElement` [Object](https://docs.microsoft.com/en-us/dotnet/api/System.Object)
`inputEventArgs` [InputEventArgs](https://docs.microsoft.com/en-us/dotnet/api/System.Windows.Input.InputEventArgs)
**Returns**
[Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean)

View File

@@ -0,0 +1,26 @@
# MultiGesture.Match Enum
**Namespace:** Nodify.Interactivity
**Assembly:** Nodify
**References:** [MultiGesture](Nodify_Interactivity_MultiGesture)
```csharp
public enum Match
```
## Fields
### All
```csharp
All = 1;
```
### Any
```csharp
Any = 0;
```

Some files were not shown because too many files have changed in this diff Show More