public void Render(LayoutInformation layout, ILayoutContext layoutContext, IDrawingContext drawingContext)
{
Point location = Location.Resolve(layout, layoutContext.Options);
var drawRect = new Rect(location, new Size(Width, Height));
switch (layout.GetFlipType())
{
case FlipType.Horizontal:
drawRect = new Rect(drawRect.X - Width, drawRect.Y, Width, Height);
break;
case FlipType.Vertical:
drawRect = new Rect(drawRect.X, drawRect.Y - Height, Width, Height);
break;
case FlipType.Both:
drawRect = new Rect(drawRect.X - Width, drawRect.Y - Height, Width, Height);
break;
}
if (layoutContext.Options.Absolute)
{
drawingContext.DrawRectangle(Point.Add(drawRect.TopLeft, layout.Location), drawRect.Size, StrokeThickness, Fill);
}
else
{
drawingContext.DrawRectangle(drawRect.TopLeft, drawRect.Size, StrokeThickness, Fill);
}
}
/// <summary>
/// Gets the smallest rectangle that bounds all of the items</summary>
/// <param name="layoutContext">Layout context</param>
/// <param name="items">Items</param>
/// <param name="bounds">Bounding rectangle (output parameter)</param>
/// <returns>Rectangle that bounds all of the items</returns>
public static BoundsSpecified GetBounds(this ILayoutContext layoutContext, IEnumerable <object> items, out Rect bounds)
{
BoundsSpecified resultFlags = BoundsSpecified.None;
Rect resultBounds = Rect.Empty;
foreach (object item in items)
{
Rect itemBounds;
BoundsSpecified itemFlags = layoutContext.GetBounds(item, out itemBounds);
if (itemFlags == BoundsSpecified.All)
{
if (resultBounds.IsEmpty)
{
resultBounds = itemBounds;
resultFlags = itemFlags;
}
else
{
resultBounds = Rect.Union(resultBounds, itemBounds);
resultFlags &= itemFlags;
}
}
}
bounds = resultBounds;
return(resultFlags);
}
/// <summary>
/// Gets the smallest rectangle that bounds all of the items</summary>
/// <param name="layoutContext">Layout context</param>
/// <param name="items">Items</param>
/// <param name="bounds">Bounding rectangle, in world coordinates (output parameter)</param>
/// <returns>Rectangle that bounds all the items</returns>
public static BoundsSpecified GetBounds(this ILayoutContext layoutContext, IEnumerable <object> items, out Rectangle bounds)
{
BoundsSpecified resultFlags = BoundsSpecified.None;
Rectangle resultBounds = new Rectangle();
bool firstTime = true;
foreach (object item in items)
{
Rectangle itemBounds;
BoundsSpecified itemFlags = layoutContext.GetBounds(item, out itemBounds);
if (itemFlags == BoundsSpecified.All)
{
if (firstTime)
{
firstTime = false;
resultBounds = itemBounds;
resultFlags = itemFlags;
}
else
{
resultBounds = Rectangle.Union(resultBounds, itemBounds);
resultFlags &= itemFlags;
}
}
}
bounds = resultBounds;
return(resultFlags);
}
public void Render(LayoutInformation layout, ILayoutContext layoutContext, IDrawingContext drawingContext)
{
var commands = new List <IPathCommand>(Commands.Count);
var flipType = layout.GetFlipType();
foreach (IPathCommand command in Commands)
{
var flippedCommand = command;
if ((flipType & FlipType.Horizontal) == FlipType.Horizontal)
{
flippedCommand = flippedCommand.Flip(true);
}
if ((flipType & FlipType.Vertical) == FlipType.Vertical)
{
flippedCommand = flippedCommand.Flip(false);
}
commands.Add(flippedCommand);
}
Point start = Start.Resolve(layout, layoutContext.Options);
if (layoutContext.Options.Absolute)
{
drawingContext.DrawPath(Point.Add(start, layout.Location), commands, Thickness, Fill);
}
else
{
drawingContext.DrawPath(start, commands, Thickness, Fill);
}
}
/// <summary>
/// Moves the items so that their bounding boxes all have the Top (y) value of the
/// top-most item</summary>
/// <param name="items">Items to move</param>
/// <param name="layoutContext">Layout context of items to move</param>
public virtual void AlignTops(IEnumerable<object> items, ILayoutContext layoutContext)
{
Rectangle bounds;
LayoutContexts.GetBounds(layoutContext, items, out bounds);
foreach (object item in items)
{
layoutContext.SetBounds(item, bounds, BoundsSpecified.Y);
}
}
/// <summary>
/// Moves the items so that their bounding boxes all have the Top (y) value of the
/// top-most item</summary>
/// <param name="items">Items to move</param>
/// <param name="layoutContext">Layout context of items to move</param>
public virtual void AlignTops(IEnumerable <object> items, ILayoutContext layoutContext)
{
Rectangle bounds;
LayoutContexts.GetBounds(layoutContext, items, out bounds);
foreach (object item in items)
{
layoutContext.SetBounds(item, bounds, BoundsSpecified.Y);
}
}
/// <summary>
/// Moves the item, so that the center of its bounding box is at the given point</summary>
/// <param name="layoutContext">Layout context containing item</param>
/// <param name="item">Item to center</param>
/// <param name="center">Centering point</param>
public static void Center(this ILayoutContext layoutContext, object item, Point center)
{
Rect oldBounds;
layoutContext.GetBounds(item, out oldBounds);
Point topLeft = new Point(
center.X - oldBounds.Width / 2,
center.Y - oldBounds.Height / 2);
layoutContext.SetBounds(item, oldBounds, new Rect(topLeft, oldBounds.Size), BoundsSpecified.Location);
}
private BoundsSpecified GetBoundsSpecified(ILayoutContext layoutContext, IEnumerable <object> items)
{
BoundsSpecified itemFlags = BoundsSpecified.None;
foreach (object item in items)
{
itemFlags |= layoutContext.CanSetBounds(item);
}
return(itemFlags);
}
/// <summary>
/// Sets the height of all of the items to that of the tallest item</summary>
/// <param name="items">Items to resize</param>
/// <param name="layoutContext">Layout context of items to resize</param>
public virtual void MakeHeightEqual(IEnumerable <object> items, ILayoutContext layoutContext)
{
Size maxSize = GetMaxSize(items, layoutContext);
foreach (object item in items)
{
Rectangle bounds;
layoutContext.GetBounds(item, out bounds);
bounds.Height = maxSize.Height;
layoutContext.SetBounds(item, bounds, BoundsSpecified.Height);
}
}
/// <summary>
/// Centers items in canvas at point</summary>
/// <param name="items">Items to center</param>
/// <param name="p">Point at which to center items</param>
public void Center(IEnumerable <object> items, Point p)
{
ILayoutContext layoutContext = this.As <ILayoutContext>();
if (layoutContext != null)
{
// get bounds, convert to world coords
Matrix transform = m_viewingContext.Control.As <ITransformAdapter>().Transform;
p = GdiUtil.InverseTransform(transform, p);
LayoutContexts.Center(layoutContext, items, p);
}
}
public void Layout(ILayoutContext context)
{
// Pre-layout.
//
foreach (var extension in context.Extensions)
{
extension.PreLayout(context);
}
try
{
// Final step in binding that transfers (moves/copies) all files generated into the appropriate
// location in the source image.
if (context.FileTransfers?.Any() == true)
{
this.Messaging.Write(VerboseMessages.LayingOutMedia());
var command = new TransferFilesCommand(this.Messaging, context.Extensions, context.FileTransfers, context.SuppressAclReset);
command.Execute();
}
if (context.TrackedFiles != null)
{
this.CleanTempFiles(context.IntermediateFolder, context.TrackedFiles);
}
}
finally
{
if (context.TrackedFiles != null)
{
if (!String.IsNullOrEmpty(context.ContentsFile))
{
this.CreateContentsFile(context.ContentsFile, context.TrackedFiles);
}
if (!String.IsNullOrEmpty(context.OutputsFile))
{
this.CreateOutputsFile(context.OutputsFile, context.TrackedFiles);
}
if (!String.IsNullOrEmpty(context.BuiltOutputsFile))
{
this.CreateBuiltOutputsFile(context.BuiltOutputsFile, context.TrackedFiles);
}
}
}
// Post-layout.
foreach (var extension in context.Extensions)
{
extension.PostLayout();
}
}
/// <summary>
/// Moves the items so that their bounding boxes all have the Left (x) value
/// of the left-most item</summary>
/// <param name="items">Items to move</param>
/// <param name="layoutContext">Layout context of items to move</param>
public virtual void AlignLefts(IEnumerable<object> items, ILayoutContext layoutContext)
{
Rectangle bounds;
LayoutContexts.GetBounds(layoutContext, items, out bounds);
foreach (object item in items)
{
Rectangle itemBounds;
layoutContext.GetBounds(item, out itemBounds);
itemBounds.X = bounds.X;
layoutContext.SetBounds(item, itemBounds, BoundsSpecified.X);
}
}
public void Render(LayoutInformation layout, ILayoutContext layoutContext, IDrawingContext drawingContext)
{
var centre = Centre.Resolve(layout, layoutContext.Options);
if (layoutContext.Options.Absolute)
{
drawingContext.DrawEllipse(Point.Add(centre, layout.Location), RadiusX, RadiusY, Thickness, Fill);
}
else
{
drawingContext.DrawEllipse(centre, RadiusX, RadiusY, Thickness, Fill);
}
}
/// <summary>
/// Moves the items so that their bounding boxes all have the Bottom (y + Height) value
/// of the bottom-most item</summary>
/// <param name="items">Items to move</param>
/// <param name="layoutContext">Layout context of items to move</param>
public virtual void AlignBottoms(IEnumerable <object> items, ILayoutContext layoutContext)
{
Rectangle bounds;
LayoutContexts.GetBounds(layoutContext, items, out bounds);
foreach (object item in items)
{
Rectangle itemBounds;
layoutContext.GetBounds(item, out itemBounds);
itemBounds.Y = bounds.Bottom - itemBounds.Height;
layoutContext.SetBounds(item, itemBounds, BoundsSpecified.Y);
}
}
/// <summary>
/// Layout the keyboard onto a Canvas.
/// </summary>
/// <param name="context">The layout context.</param>
internal void Layout(ILayoutContext context)
{
var y = context.Top;
foreach (var row in Rows)
{
var height = row.Height * context.KeySize;
row.Layout(context, y, height);
y += height;
}
}
/// <summary>
/// Moves the items so that their bounding boxes all have the Right (x + Width) value
/// of the right-most item</summary>
/// <param name="items">Items to move</param>
/// <param name="layoutContext">Layout context of items to move</param>
public virtual void AlignRights(IEnumerable <object> items, ILayoutContext layoutContext)
{
Rectangle bounds;
LayoutContexts.GetBounds(layoutContext, items, out bounds);
foreach (object item in items)
{
Rectangle itemBounds;
layoutContext.GetBounds(item, out itemBounds);
itemBounds.X = bounds.Right - itemBounds.Width;
layoutContext.SetBounds(item, itemBounds, BoundsSpecified.X);
}
}
private Size GetMaxSize(IEnumerable <object> items, ILayoutContext layoutContext)
{
Size size = new Size();
foreach (object item in items)
{
Rectangle bounds;
layoutContext.GetBounds(item, out bounds);
size = new Size(
Math.Max(size.Width, bounds.Width),
Math.Max(size.Height, bounds.Height));
}
return(size);
}
internal void Layout(ILayoutContext context, double top, double height)
{
var x = context.Left;
foreach (var key in Keys)
{
var width = context.KeySize * key.CalculateWidth();
var y = top + context.KeySize * key.CalculateTopOffset();
key.Layout(context, x, y, width, height);
x += width;
}
}
public void Render(LayoutInformation layout, ILayoutContext layoutContext, IDrawingContext drawingContext)
{
var start = Start.Resolve(layout, layoutContext.Options);
var end = End.Resolve(layout, layoutContext.Options);
if (layoutContext.Options.Absolute)
{
drawingContext.DrawLine(Point.Add(start, layout.Location), Point.Add(end, layout.Location), Thickness);
}
else
{
drawingContext.DrawLine(start, end, Thickness);
}
}
public ILayoutAlgorithm <TVertex, TEdge, TGraph> CreateAlgorithm(string newAlgorithmType,
ILayoutContext <TVertex, TEdge, TGraph> context, ILayoutParameters parameters)
{
var layoutContext = context as ContextualLayoutContext <TVertex, TEdge, TGraph>;
switch (newAlgorithmType)
{
/*case "DoubleTree":
* return new DoubleTreeLayoutAlgorithm<TVertex, TEdge, TGraph>( layoutContext.Graph, layoutContext.Positions, layoutContext.Sizes, parameters as DoubleTreeLayoutParameters, layoutContext.SelectedVertex );
* case "BalloonTree":
* return new BalloonTreeLayoutAlgorithm<TVertex, TEdge, TGraph>( layoutContext.Graph, layoutContext.Positions, layoutContext.Sizes, parameters as BalloonTreeLayoutParameters, layoutContext.SelectedVertex );*/
default:
return(null);
}
}
/// <summary>
/// Checks whether the client can do the command, if it handles it</summary>
/// <param name="commandTag">Command to be done</param>
/// <returns>True iff client can do the command</returns>
public virtual bool CanDoCommand(object commandTag)
{
bool canDo = false;
ILayoutContext layoutContext = m_contextRegistry.GetActiveContext <ILayoutContext>();
ISelectionContext selectionContext = m_contextRegistry.GetActiveContext <ISelectionContext>();
if (layoutContext != null &&
selectionContext != null)
{
BoundsSpecified itemFlags = GetBoundsSpecified(layoutContext, selectionContext.Selection);
if (itemFlags != BoundsSpecified.None)
{
switch ((StandardCommand)commandTag)
{
case StandardCommand.FormatAlignLefts:
case StandardCommand.FormatAlignCenters: //horizontal middle
case StandardCommand.FormatAlignRights:
canDo = (itemFlags & BoundsSpecified.X) != 0;
break;
case StandardCommand.FormatAlignTops:
case StandardCommand.FormatAlignMiddles: //vertical middle
case StandardCommand.FormatAlignBottoms:
canDo = (itemFlags & BoundsSpecified.Y) != 0;
break;
case StandardCommand.FormatMakeWidthEqual:
canDo = (itemFlags & BoundsSpecified.Width) != 0;
break;
case StandardCommand.FormatMakeHeightEqual:
canDo = (itemFlags & BoundsSpecified.Height) != 0;
break;
case StandardCommand.FormatMakeSizeEqual:
canDo = (itemFlags & BoundsSpecified.Size) == BoundsSpecified.Size;
break;
}
}
}
return(canDo);
}
/// <inheritdoc />
public ILayoutAlgorithm <TVertex, TEdge, TGraph> CreateAlgorithm(
string algorithmType,
ILayoutContext <TVertex, TEdge, TGraph> context,
ILayoutParameters parameters)
{
if (algorithmType is null)
{
throw new ArgumentNullException(nameof(algorithmType));
}
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
var layoutContext = context as ContextualLayoutContext <TVertex, TEdge, TGraph>;
if (layoutContext is null)
{
throw new ArgumentException(
$"Layout context must be a not null {nameof(ContextualLayoutContext<TVertex, TEdge, TGraph>)}.",
nameof(context));
}
switch (algorithmType)
{
case DoubleTreeAlgorithm:
return(new DoubleTreeLayoutAlgorithm <TVertex, TEdge, TGraph>(
layoutContext.Graph,
layoutContext.Positions,
layoutContext.Sizes,
layoutContext.SelectedVertex,
parameters as DoubleTreeLayoutParameters));
case BalloonTreeAlgorithm:
return(new BalloonTreeLayoutAlgorithm <TVertex, TEdge, TGraph>(
layoutContext.Graph,
layoutContext.Positions,
layoutContext.SelectedVertex,
parameters as BalloonTreeLayoutParameters));
}
return(null);
}
/// <inheritdoc />
public ILayoutAlgorithm <TVertex, TEdge, TGraph> CreateAlgorithm(
string algorithmType,
ILayoutContext <TVertex, TEdge, TGraph> context,
ILayoutParameters parameters)
{
if (algorithmType is null)
{
throw new ArgumentNullException(nameof(algorithmType));
}
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (context.Graph is null)
{
return(null);
}
return(CreateAlgorithmInternal(algorithmType, context, parameters));
}
internal override void Layout(ILayoutContext context, double left, double top, double width, double height)
{
// Collect together all the states.
var availableStates = new HashSet <string>();
foreach (var conditional in Conditionals)
{
var state = conditional.Name;
if (state != null)
{
availableStates.Add(state);
}
}
foreach (var conditional in Conditionals)
{
if (conditional.Name == null)
{
context.SetDefaultBinding(availableStates);
}
else
{
context.SetNamedBinding(conditional.Name);
}
var x = left;
foreach (var key in conditional.Keys)
{
var keyWidth = context.KeySize * key.CalculateWidth();
var y = top + context.KeySize * key.CalculateTopOffset();
key.Layout(context, x, y, keyWidth, height);
x += keyWidth;
}
context.ResetBinding();
}
}
/// <summary>
/// Moves all items so that the center of their bounding box is at the given point</summary>
/// <param name="layoutContext">Layout context containing item</param>
/// <param name="items">Items to center</param>
/// <param name="center">Centering point</param>
public static void Center(this ILayoutContext layoutContext, IEnumerable <object> items, Point center)
{
Rect bounds;
GetBounds(layoutContext, items, out bounds);
// calculate offset
Point offset = new Point(
center.X - (bounds.Left + bounds.Width / 2),
center.Y - (bounds.Top + bounds.Height / 2));
foreach (object item in items)
{
Rect itemBounds;
layoutContext.GetBounds(item, out itemBounds);
Point topLeft = new Point(
itemBounds.Left + offset.X,
itemBounds.Top + offset.Y);
layoutContext.SetBounds(item, itemBounds, new Rect(topLeft, itemBounds.Size), BoundsSpecified.Location);
}
}
public void Render(LayoutInformation layout, ILayoutContext layoutContext, IDrawingContext drawingContext)
{
Point location = Location.Resolve(layout, layoutContext.Options);
var drawRect = new Rect(location, new Size(Width, Height));
if (layout.IsFlipped && layout.Orientation == Orientation.Horizontal)
{
drawRect = new Rect(drawRect.X - Width, drawRect.Y, Width, Height);
}
else if (layout.IsFlipped && layout.Orientation == Orientation.Vertical)
{
drawRect = new Rect(drawRect.X, drawRect.Y - Height, Width, Height);
}
if (layoutContext.Options.Absolute)
{
drawingContext.DrawRectangle(Point.Add(drawRect.TopLeft, layout.Location), drawRect.Size, StrokeThickness, Fill);
}
else
{
drawingContext.DrawRectangle(drawRect.TopLeft, drawRect.Size, StrokeThickness, Fill);
}
}
public void Render(LayoutInformation layout, ILayoutContext layoutContext, IDrawingContext drawingContext)
{
IList <IPathCommand> commands = Commands;
if (layout.IsFlipped)
{
commands = new List <IPathCommand>(Commands.Count);
foreach (IPathCommand command in Commands)
{
commands.Add(command.Flip(layout.Orientation == Orientation.Horizontal));
}
}
Point start = Start.Resolve(layout, layoutContext.Options);
if (layoutContext.Options.Absolute)
{
drawingContext.DrawPath(Point.Add(start, layout.Location), commands, Thickness, Fill);
}
else
{
drawingContext.DrawPath(start, commands, Thickness, Fill);
}
}
internal override void Layout(ILayoutContext context, double left, double top, double width, double height)
{
context.CreateActionKey(this, left, top, width, height);
}
private Size GetMaxSize(IEnumerable<object> items, ILayoutContext layoutContext)
{
Size size = new Size();
foreach (object item in items)
{
Rectangle bounds;
layoutContext.GetBounds(item, out bounds);
size = new Size(
Math.Max(size.Width, bounds.Width),
Math.Max(size.Height, bounds.Height));
}
return size;
}
private BoundsSpecified GetBoundsSpecified(ILayoutContext layoutContext, IEnumerable<object> items)
{
BoundsSpecified itemFlags = BoundsSpecified.None;
foreach (object item in items)
itemFlags |= layoutContext.CanSetBounds(item);
return itemFlags;
}
/// <summary>
/// Sets the height of all of the items to that of the tallest item</summary>
/// <param name="items">Items to resize</param>
/// <param name="layoutContext">Layout context of items to resize</param>
public virtual void MakeHeightEqual(IEnumerable<object> items, ILayoutContext layoutContext)
{
Size maxSize = GetMaxSize(items, layoutContext);
foreach (object item in items)
{
Rectangle bounds;
layoutContext.GetBounds(item, out bounds);
bounds.Height = maxSize.Height;
layoutContext.SetBounds(item, bounds, BoundsSpecified.Height);
}
}
/// <summary>
/// Moves the items up or down so that their bounding box centers all have the same
/// Y value, which is the Y value of the center of the bounding box around the items'
/// original positions</summary>
/// <param name="items">Items to move</param>
/// <param name="layoutContext">Layout context of items to move</param>
public virtual void AlignMiddles(IEnumerable<object> items, ILayoutContext layoutContext)
{
Rectangle bounds;
LayoutContexts.GetBounds(layoutContext, items, out bounds);
int boundsMiddle = (bounds.Top + bounds.Bottom) / 2;
foreach (object item in items)
{
Rectangle itemBounds;
layoutContext.GetBounds(item, out itemBounds);
itemBounds.Y = boundsMiddle - itemBounds.Height / 2;
layoutContext.SetBounds(item, itemBounds, BoundsSpecified.Y);
}
}
/// <summary>
/// Moves the items left or right so that their bounding box centers all have the same
/// X value, which is the X value of the center of the bounding box around the items'
/// original positions</summary>
/// <param name="items">Items to move</param>
/// <param name="layoutContext">Layout context of items to move</param>
public virtual void AlignCenters(IEnumerable<object> items, ILayoutContext layoutContext)
{
Rectangle bounds;
LayoutContexts.GetBounds(layoutContext, items, out bounds);
int boundsCenter = (bounds.Left + bounds.Right) / 2;
foreach (object item in items)
{
Rectangle itemBounds;
layoutContext.GetBounds(item, out itemBounds);
itemBounds.X = boundsCenter - itemBounds.Width / 2;
layoutContext.SetBounds(item, itemBounds, BoundsSpecified.X);
}
}
ILayoutAlgorithm <TVertex, TEdge, TGraph> ILayoutAlgorithmFactory <TVertex, TEdge, TGraph> .CreateAlgorithm(string newAlgorithmType, ILayoutContext <TVertex, TEdge, TGraph> context, ILayoutParameters parameters)
{
Contract.Requires(newAlgorithmType != null);
Contract.Requires(context as ContextualLayoutContext <TVertex, TEdge, TGraph> != null);
var laf = (ILayoutAlgorithmFactory <TVertex, TEdge, TGraph>) this;
Contract.Requires(laf.AlgorithmTypes.Contains(newAlgorithmType));
return(default(ILayoutAlgorithm <TVertex, TEdge, TGraph>));
}
/// <summary>
/// Does the command</summary>
/// <param name="commandTag">Command to be done</param>
public virtual void DoCommand(object commandTag)
{
ISelectionContext selectionContext = m_contextRegistry.GetActiveContext <ISelectionContext>();
ILayoutContext layoutContext = m_contextRegistry.GetActiveContext <ILayoutContext>();
if (layoutContext != null &&
selectionContext != null)
{
IEnumerable <object> items = selectionContext.Selection;
BoundsSpecified itemFlags = GetBoundsSpecified(layoutContext, selectionContext.Selection);
if (itemFlags != BoundsSpecified.None)
{
string commandName = null;
switch ((StandardCommand)commandTag)
{
case StandardCommand.FormatAlignLefts:
commandName = CommandInfo.FormatAlignLefts.MenuText;
break;
case StandardCommand.FormatAlignRights:
commandName = CommandInfo.FormatAlignRights.MenuText;
break;
case StandardCommand.FormatAlignCenters: //horizontal middle
commandName = CommandInfo.FormatAlignCenters.MenuText;
break;
case StandardCommand.FormatAlignTops: //horizontal middle
commandName = CommandInfo.FormatAlignTops.MenuText;
break;
case StandardCommand.FormatAlignBottoms:
commandName = CommandInfo.FormatAlignBottoms.MenuText;
break;
case StandardCommand.FormatAlignMiddles: //vertical middle
commandName = CommandInfo.FormatAlignMiddles.MenuText;
break;
case StandardCommand.FormatMakeWidthEqual:
commandName = CommandInfo.FormatMakeWidthEqual.MenuText;
break;
case StandardCommand.FormatMakeHeightEqual:
commandName = CommandInfo.FormatMakeHeightEqual.MenuText;
break;
case StandardCommand.FormatMakeSizeEqual:
commandName = CommandInfo.FormatMakeSizeEqual.MenuText;
break;
}
ITransactionContext transactionContext = m_contextRegistry.GetActiveContext <ITransactionContext>();
transactionContext.DoTransaction(delegate
{
switch ((StandardCommand)commandTag)
{
case StandardCommand.FormatAlignLefts:
AlignLefts(items, layoutContext);
break;
case StandardCommand.FormatAlignRights:
AlignRights(items, layoutContext);
break;
case StandardCommand.FormatAlignCenters: // horizontal center
AlignCenters(items, layoutContext);
break;
case StandardCommand.FormatAlignTops:
AlignTops(items, layoutContext);
break;
case StandardCommand.FormatAlignBottoms:
AlignBottoms(items, layoutContext);
break;
case StandardCommand.FormatAlignMiddles: // vertical center
AlignMiddles(items, layoutContext);
break;
case StandardCommand.FormatMakeWidthEqual:
MakeWidthEqual(items, layoutContext);
break;
case StandardCommand.FormatMakeHeightEqual:
MakeHeightEqual(items, layoutContext);
break;
case StandardCommand.FormatMakeSizeEqual:
MakeSizeEqual(items, layoutContext);
break;
}
},
commandName);
}
}
}
public void Render(LayoutInformation layout, ILayoutContext layoutContext, IDrawingContext drawingContext)
{
Point renderLocation = Location.Resolve(layout, layoutContext.Options);
TextAlignment tempAlignment = Alignment;
var flipType = layout.GetFlipType();
if ((flipType & FlipType.Horizontal) == FlipType.Horizontal)
{
switch (Alignment)
{
case TextAlignment.BottomLeft:
tempAlignment = TextAlignment.BottomRight;
break;
case TextAlignment.BottomRight:
tempAlignment = TextAlignment.BottomLeft;
break;
case TextAlignment.CentreLeft:
tempAlignment = TextAlignment.CentreRight;
break;
case TextAlignment.CentreRight:
tempAlignment = TextAlignment.CentreLeft;
break;
case TextAlignment.TopLeft:
tempAlignment = TextAlignment.TopRight;
break;
case TextAlignment.TopRight:
tempAlignment = TextAlignment.TopLeft;
break;
}
}
if ((flipType & FlipType.Vertical) == FlipType.Vertical)
{
switch (Alignment)
{
case TextAlignment.BottomCentre:
tempAlignment = TextAlignment.TopCentre;
break;
case TextAlignment.BottomLeft:
tempAlignment = TextAlignment.TopLeft;
break;
case TextAlignment.BottomRight:
tempAlignment = TextAlignment.TopRight;
break;
case TextAlignment.TopCentre:
tempAlignment = TextAlignment.BottomCentre;
break;
case TextAlignment.TopLeft:
tempAlignment = TextAlignment.BottomLeft;
break;
case TextAlignment.TopRight:
tempAlignment = TextAlignment.BottomRight;
break;
}
}
List <TextRun> renderTextRuns = new List <TextRun>(TextRuns.Count);
// Build runs
foreach (TextRun run in TextRuns)
{
// Resolve value
string renderValue;
if (run.Text.StartsWith("$"))
{
renderValue = layoutContext.GetFormattedVariable(run.Text);
}
else
{
renderValue = run.Text;
}
System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@"\\[uU]([0-9A-F]{4})");
renderValue = regex.Replace(renderValue, match => ((char)int.Parse(match.Value.Substring(2), System.Globalization.NumberStyles.HexNumber)).ToString());
renderTextRuns.Add(new TextRun(renderValue, run.Formatting));
}
if (layoutContext.Options.Absolute)
{
drawingContext.DrawText(Point.Add(renderLocation, layout.Location), tempAlignment, (int)Rotation * 90, renderTextRuns);
}
else
{
drawingContext.DrawText(renderLocation, tempAlignment, (int)Rotation * 90, renderTextRuns);
}
}
public ILayoutAlgorithm <TVertex, TEdge, TGraph> CreateAlgorithm(string newAlgorithmType, ILayoutContext <TVertex, TEdge, TGraph> context, ILayoutParameters parameters)
{
if (context == null || context.Graph == null)
{
return(null);
}
if (context.Mode == LayoutMode.Simple)
{
switch (newAlgorithmType)
{
case "Tree":
return(new SimpleTreeLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Positions,
context.Sizes,
parameters as SimpleTreeLayoutParameters));
case "Circular":
return(new CircularLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Positions,
context.Sizes,
parameters as CircularLayoutParameters));
case "FR":
return(new FRLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Positions,
parameters as FRLayoutParametersBase));
case "BoundedFR":
return(new FRLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Positions,
parameters as BoundedFRLayoutParameters));
case "KK":
return(new KKLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Positions,
parameters as KKLayoutParameters));
case "ISOM":
return(new ISOMLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Positions,
parameters as ISOMLayoutParameters));
case "LinLog":
return(new LinLogLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Positions,
parameters as LinLogLayoutParameters));
case "EfficientSugiyama":
return(new EfficientSugiyamaLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph,
parameters as EfficientSugiyamaLayoutParameters,
context.Positions,
context.Sizes));
case "Sugiyama":
return(new SugiyamaLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Sizes,
context.Positions,
parameters as
SugiyamaLayoutParameters,
e => (e is TypedEdge <TVertex>
?(e as TypedEdge <TVertex>).Type
: EdgeTypes.Hierarchical)));
case "CompoundFDP":
return(new CompoundFDPLayoutAlgorithm <TVertex, TEdge, TGraph>(
context.Graph,
context.Sizes,
new Dictionary <TVertex, Thickness>(),
new Dictionary <TVertex, CompoundVertexInnerLayoutType>(),
context.Positions,
parameters as CompoundFDPLayoutParameters));
default:
return(null);
}
}
else if (context.Mode == LayoutMode.Compound)
{
var compoundContext = context as ICompoundLayoutContext <TVertex, TEdge, TGraph>;
switch (newAlgorithmType)
{
case "CompoundFDP":
return(new CompoundFDPLayoutAlgorithm <TVertex, TEdge, TGraph>(
compoundContext.Graph,
compoundContext.Sizes,
compoundContext.VertexBorders,
compoundContext.LayoutTypes,
compoundContext.Positions,
parameters as CompoundFDPLayoutParameters));
default:
return(null);
}
}
return(null);
}
