public static void Set(this MutableRectangle mutable, IRectangle r)
{
mutable.X = r.X;
mutable.Y = r.Y;
mutable.Width = r.Width;
mutable.Height = r.Height;
}
private void OnWindowLoaded(object sender, RoutedEventArgs e)
{
IGraph graph = graphControl.Graph;
// Create a default editor input mode
GraphEditorInputMode graphEditorInputMode = new GraphEditorInputMode();
// Just for user convenience: disable node and edge creation,
graphEditorInputMode.AllowCreateEdge = false;
graphEditorInputMode.AllowCreateNode = false;
// disable deleting items
graphEditorInputMode.DeletableItems = GraphItemTypes.None;
// disable node moving
graphEditorInputMode.MovableItems = GraphItemTypes.None;
// enable the undo feature
graph.SetUndoEngineEnabled(true);
// Finally, set the input mode to the graph control.
graphControl.InputMode = graphEditorInputMode;
// Create the rectangle that limits the movement of some nodes
// and add it to the GraphControl.
var boundaryRectangle = new MutableRectangle(210, 350, 30, 30);
graphControl.RootGroup.AddChild(boundaryRectangle, new LimitingRectangleDescriptor());
RegisterSizeConstraintProvider(boundaryRectangle);
CreateSampleGraph(graph);
// reset the Undo queue so the initial graph creation cannot be undone
graph.GetUndoEngine().Clear();
}
public void ReshapeFinished(IInputModeContext context, RectD originalBounds, RectD newBounds)
{
shadowObject.Remove();
simulationRectangle = null;
originalHandler.HandleReshape(context, this.originalBounds, newBounds);
originalHandler.ReshapeFinished(context, this.originalBounds, newBounds);
}
static void Main(string[] args)
{
#region Level 0
string name = " 123456 ";
name.Trim();
Console.WriteLine(name.Length);
name = name.Trim(); // immutable always returns a new string
Console.WriteLine(name.Length);
#endregion
#region Basic
var r1 = new MutableRectangle();
r1.Height = 10;
r1.Length = 5;
r1.Grow(10, 5);
Console.WriteLine(r1.ToString());
#endregion
#region Patterns
#region 1. Mutable
var m = new Mutable();
m.Value = 10;
m.Value = 20;
#endregion
#region 2. ShallowMutable
StringBuilder builder = new StringBuilder();
builder.Append("foo");
var sm = new ShallowMutable(10, builder);
sm.Builder.Append("bar");
Console.WriteLine(sm.Builder);
#endregion
#region 3. Popsicle
var p = new Popsicle();
p.Value = 10;
p.Freeze();
//p.Value = 20; //Bang!
#endregion
#region 4. ObservableImmutable
#endregion
#endregion
Console.ReadLine();
}
public void Prove_mutability()
{
var rectangle = new MutableRectangle(1, 2);
var rectangleBackup = rectangle;
rectangle.Grow(10);
Assert.Equal(11, rectangle.Width);
Assert.NotEqual(1, rectangleBackup.Width);
Assert.Same(rectangle, rectangleBackup);
}
public IVisual CreateVisual(IRenderContext context)
{
rectangle = new MutableRectangle(RectD.FromCenter(Center, new SizeD(PageWidth + Margin, PageHeight + Margin)));
var rectVisual = new RectangleVisual(rectangle)
{
Pen = new Pen(Color.Black, 1)
{
DashStyle = DashStyle.Dash
}
};
return(rectVisual);
}
private void InitializeInputModes()
{
// Create a GraphEditorInputMode instance
var editMode = new GraphEditorInputMode();
// and install the edit mode into the canvas.
graphControl.InputMode = editMode;
// create the model for the export rectangle
exportRect = new MutableRectangle(0, 0, 100, 100);
// visualize it
new RectangleIndicatorInstaller(exportRect, RectangleIndicatorInstaller.SelectionTemplateKey)
.AddCanvasObject(graphControl.CanvasContext, graphControl.BackgroundGroup, exportRect);
AddExportRectInputModes(editMode);
}
/// <summary>
/// Registers the <see cref="GraphEditorInputMode"/> as the <see cref="CanvasControl.InputMode"/>
/// and initializes the rectangular area so that it is drawn and can be moved and resized.
/// </summary>
private void InitializeInputModes()
{
// create a GraphEditorInputMode instance
var editMode = new GraphEditorInputMode();
// and install the edit mode into the canvas.
GraphControl.InputMode = editMode;
// create the model for the rectangular area
clearRect = new MutableRectangle(0, 0, 100, 100);
// visualize it
new RectangleIndicatorInstaller(clearRect, ClearRectTemplateKey)
.AddCanvasObject(GraphControl.CanvasContext, GraphControl.HighlightGroup, clearRect);
AddClearRectInputModes(editMode);
}
public void InitializeReshape(IInputModeContext context)
{
simulationRectangle = new MutableRectangle(originalHandler.Bounds);
var node = new SimpleNode {
Layout = simulationRectangle,
Style =
new ShapeNodeStyle {
Shape = ShapeNodeShape.RoundRectangle,
Brush = Brushes.Transparent,
Pen = new Pen(Brushes.Gray, 2)
}
};
shadowObject = context.CanvasControl.RootGroup.AddChild(node, GraphModelManager.DefaultNodeDescriptor).ToFront();
originalHandler.InitializeReshape(context);
originalBounds = originalHandler.Bounds.ToRectD();
}
/// <summary>
/// Shows how to register the custom <see cref="IPositionHandler"/> implementations with the <see cref="IGraph"/>'s
/// <see cref="ILookupDecorator"/> mechanism.
/// </summary>
private void RegisterPositionHandler(MutableRectangle boundaryRectangle)
{
var nodeDecorator = graphControl.Graph.GetDecorator().NodeDecorator;
nodeDecorator.PositionHandlerDecorator.SetImplementationWrapper(
(node, delegateHandler) => {
// Obtain the tag from the node
object nodeTag = node.Tag;
// Check if it is a known tag and choose the respective implementation.
// Fallback to the default behavior otherwise.
if (!(nodeTag is Color))
{
return(delegateHandler);
}
else if (Color.Orange.Equals(nodeTag))
{
// This implementation delegates certain behavior to the default implementation
return(new OrangePositionHandler(boundaryRectangle, node, delegateHandler));
}
else if (Color.Firebrick.Equals(nodeTag))
{
// A simple implementation that prohibits moving
return(new RedPositionHandler());
}
else if (Color.RoyalBlue.Equals(nodeTag))
{
// Implementation that uses two levels of delegation to create a combined behavior
return(new OrangePositionHandler(boundaryRectangle, node, new GreenPositionHandler(delegateHandler)));
}
else if (Color.Green.Equals(nodeTag))
{
// Another implementation that delegates certain behavior to the default implementation
return(new GreenPositionHandler(delegateHandler));
}
else
{
return(delegateHandler);
}
});
}
private void FormLoaded(object sender, EventArgs e)
{
IGraph graph = graphControl.Graph;
// Create a default editor input mode
GraphEditorInputMode graphEditorInputMode = new GraphEditorInputMode();
// Just for user convenience: disable node and edge creation,
graphEditorInputMode.AllowCreateEdge = false;
graphEditorInputMode.AllowCreateNode = false;
// disable deleting items
graphEditorInputMode.DeletableItems = GraphItemTypes.None;
// don't show resize handles,
graphEditorInputMode.ShowHandleItems = GraphItemTypes.None;
// disable clipboard,
graphEditorInputMode.AllowClipboardOperations = false;
// and enable the undo feature.
graph.SetUndoEngineEnabled(true);
// Finally, set the input mode to the graph control.
graphControl.InputMode = graphEditorInputMode;
// Create the rectangle that limits the movement of some nodes
// and add it to the GraphControl.
var boundaryRectangle = new MutableRectangle(20, 20, 480, 400);
var rectangle = new RectangleVisual(boundaryRectangle)
{
Pen = Pens.Black
};
graphControl.RootGroup.AddChild(rectangle, CanvasObjectDescriptors.Visual);
RegisterPositionHandler(boundaryRectangle);
CreateSampleGraph(graph);
// reset the Undo queue so the initial graph creation cannot be undone
graph.GetUndoEngine().Clear();
}
/// <summary>
/// Registers a callback function as decorator that provides a custom
/// <see cref="INodeSizeConstraintProvider"/> for each node.
/// </summary>
/// <remarks>
/// This callback function is called whenever a node in the graph is queried
/// for its <see cref="INodeSizeConstraintProvider"/>. In this case, the 'node' parameter will be set
/// to that node.
/// </remarks>
public void RegisterSizeConstraintProvider(MutableRectangle boundaryRectangle)
{
// One shared instance that will be used by all blue nodes
var blueSizeConstraintProvider = new BlueSizeConstraintProvider();
var nodeDecorator = graphControl.Graph.GetDecorator().NodeDecorator;
nodeDecorator.SizeConstraintProviderDecorator.SetFactory(
node => {
// Obtain the tag from the node
object nodeTag = node.Tag;
// Check if it is a known tag and choose the respective implementation.
// Fallback to the default behavior otherwise.
if (!(nodeTag is Color))
{
return(null);
}
else if (Color.RoyalBlue.Equals(nodeTag))
{
return(blueSizeConstraintProvider);
}
else if (Color.Green.Equals(nodeTag))
{
return(new GreenSizeConstraintProvider());
}
else if (Color.Orange.Equals(nodeTag))
{
return(new NodeSizeConstraintProvider(
new SizeD(50, 50), new SizeD(300, 300), boundaryRectangle.ToRectD()));
}
else
{
return(null);
}
});
}
public IVisualCreator GetVisualCreator(object forUserObject)
{
this.rect = (MutableRectangle)forUserObject;
return(this);
}
public OrangePositionHandler(MutableRectangle boundaryRectangle, INode node, IPositionHandler wrappedHandler)
: base(wrappedHandler)
{
this.boundaryRectangle = boundaryRectangle;
this.node = node;
}
/// <summary>
/// Initializes the helper.
/// </summary>
/// <param name="graphControl">The control that displays the graph.</param>
/// <param name="clearRect">The rectangle the is dragged.</param>
/// <param name="options">Options to control the layout behavior.</param>
public ClearAreaLayoutHelper(GraphControl graphControl, MutableRectangle clearRect, InteractiveClearAreaForm.LayoutOptions options)
{
this.graphControl = graphControl;
this.clearRect = clearRect;
this.options = options;
}
public void CancelReshape(IInputModeContext context, RectD originalBounds)
{
shadowObject.Remove();
simulationRectangle = null;
originalHandler.CancelReshape(context, this.originalBounds);
}
