/// <summary>
/// For the given parameter, calculate the actual geometry of the specified label in absolute world coordinates.
/// </summary>
/// <remarks>The actual position is calculated from the <see cref="MyNodeLabelModelParameter.Ratio"/> specified in the parameter as
/// the counterclock-wise angle on the label owner's circumference. Note that we also rotate the label layout itself accordingly.</remarks>
public IOrientedRectangle GetGeometry(ILabel label, ILabelModelParameter parameter)
{
var modelParameter = parameter as MyNodeLabelModelParameter;
var ownerNode = label.Owner as INode;
if (modelParameter != null && ownerNode != null)
{
//If we have a matching parameter and a node as owner, calculate the angle for the label position and the matchin rotation of the label layout box itself.
var center = ownerNode.Layout.GetCenter();
var radius = Math.Max(ownerNode.Layout.Width, ownerNode.Layout.Height) * 0.5d;
var ratio = modelParameter.Ratio;
double angle = ratio * Math.PI * 2;
double x = Math.Sin(angle);
double y = Math.Cos(angle);
PointD up = new PointD(-y, x);
OrientedRectangle result = new OrientedRectangle();
result.SetUpVector(up);
result.Size = label.PreferredSize;
result.SetCenter(center + (offset + radius + label.PreferredSize.Height * 0.5d) * up);
return(result);
}
else
{
return(OrientedRectangle.Empty);
}
}
/// <inheritdoc/>
public IOrientedRectangle GetGeometry(ILabel label, ILabelModelParameter parameter)
{
OrientedRectangle rect = new OrientedRectangle(0, 0, 10, 10);
((RatioParameter)parameter).SetGeometry(this, label, rect);
return(rect);
}
/// <summary>
/// Determines, if these two parameters are equal.
/// </summary>
/// <returns></returns>
public static bool GetEqualParameters(ILabelModelParameter parameter1, ILabelModelParameter parameter2)
{
if (parameter1 is ParticipantParameter && parameter2 is ParticipantParameter)
{
if (((ParticipantParameter)parameter1).index == ((ParticipantParameter)parameter2).index &&
((ParticipantParameter)parameter1).top == ((ParticipantParameter)parameter2).top)
{
return(true);
}
}
if (parameter1 is TaskNameBandParameter && parameter2 is TaskNameBandParameter)
{
return(true);
}
if (parameter1 is MessageParameter && parameter2 is MessageParameter)
{
if (((MessageParameter)parameter1).North == ((MessageParameter)parameter2).North)
{
return(true);
}
}
return(false);
}
static ScalingLabelModel()
{
stretchModel = new InteriorStretchLabelModel();
stretchParameter = stretchModel.CreateParameter(InteriorStretchLabelModel.Position.Center);
dummyNode = new SimpleNode();
dummyLabel = new SimpleLabel(dummyNode, "", stretchParameter);
}
public SideSliderParameter(SideSliderEdgeLabelModel model, SliderParameterLocation location,
ILabelModelParameter parameter)
{
this.model = model;
this.location = location;
this.parameter = parameter;
}
public MyEditLabelHelper(ILabelOwner owner, ILabel label, ILabelModelParameter firstLabelParam, ILabelStyle firstLabelStyle)
{
this.owner = owner;
this.label = label;
this.firstLabelParam = firstLabelParam;
this.firstLabelStyle = firstLabelStyle;
TextBoxBackground = Color.LightGray;
TextBoxForeground = Color.DarkSlateGray;
}
static MessageParameter()
{
var slm = new SandwichLabelModel {
YOffset = 32
};
northParameter = slm.CreateNorthParameter();
southParameter = slm.CreateSouthParameter();
}
/// <summary>
/// Returns an enumerator over a set of possible <see cref="ILabelModelParameter"/>
/// instances that can be used for the given label and model.
/// </summary>
/// <remarks>Since in <see cref="Lookup"/>, we return an instance of this class only for positive <see cref="CandidateCount"/>s,
/// this method is only called for <b>discrete</b> candidates.</remarks>
IEnumerable <ILabelModelParameter> ILabelModelParameterProvider.GetParameters(ILabel label, ILabelModel model)
{
var parameters = new ILabelModelParameter[candidateCount];
for (int i = 0; i < parameters.Length; i++)
{
parameters[i] = new MyNodeLabelModelParameter(this, (double)i / (parameters.Length));
}
return(parameters);
}
public PlacedIcon(IIcon innerIcon, ILabelModelParameter placementParameter, SizeD minimumSize)
{
this.innerIcon = innerIcon;
this.placementParameter = placementParameter;
dummyNode = new SimpleNode();
dummyLabel = new SimpleLabel(dummyNode, "", placementParameter)
{
PreferredSize = minimumSize
};
}
static ChoreographyLabelModel()
{
Instance = new ChoreographyLabelModel();
TaskNameBand = new TaskNameBandParameter();
NorthMessage = new MessageParameter {
North = true
};
SouthMessage = new MessageParameter {
North = false
};
}
public IOrientedRectangle GetGeometry(ILabel label, ILabelModelParameter parameter)
{
if (parameter is ChoreographyParameter && label.Owner is INode && ((INode)label.Owner).Style is ChoreographyNodeStyle)
{
return(((ChoreographyParameter)parameter).GetGeometry(label));
}
else if (label.Owner is INode)
{
var layout = ((INode)label.Owner).Layout;
return(new OrientedRectangle(layout.X, layout.Y + layout.Height, layout.Width, layout.Height));
}
return(OrientedRectangle.Empty);
}
/// <summary>
/// Helper method that applies the label model parameter to all edge labels in the graph.
/// </summary>
/// <param name="graph">The graph to apply the label model parameter.</param>
/// <param name="param">The parameter to use.</param>
protected virtual void ApplyModelToIGraph(IGraph graph, ILabelModelParameter param)
{
if (param != null)
{
foreach (ILabel label in graph.Labels)
{
if (label.Owner is IEdge)
{
graph.SetLabelLayoutParameter(label, param);
}
}
}
}
/// <inheritdoc/>
public IOrientedRectangle GetGeometry(ILabel label, ILabelModelParameter parameter)
{
SideSliderParameter param = parameter as SideSliderParameter;
if (param != null)
{
return(param.parameter.Model.GetGeometry(label, param.parameter));
}
else
{
return(new OrientedRectangle());
}
}
/// <summary>
/// Creates a new instance.
/// </summary>
public ChoreographyMessageLabelStyle()
{
delegateStyle = new ConnectedIconLabelStyle
{
IconSize = BpmnConstants.MessageSize,
IconStyle = messageStyle,
TextStyle = textStyle,
ConnectorStyle = connectorStyle,
LabelConnectorLocation = FreeNodePortLocationModel.NodeBottomAnchored,
NodeConnectorLocation = FreeNodePortLocationModel.NodeTopAnchored
};
TextPlacement = defaultTextPlacement;
}
///<inheritdoc/>
public IOrientedRectangle GetGeometry(ILabel label, ILabelModelParameter parameter)
{
ScalingParameter scalingParameter = (ScalingParameter)parameter;
if (!(label.Owner is INode))
{
return(OrientedRectangle.Empty);
}
var availableRect = ((INode)label.Owner).Layout.ToRectD();
var horizontalInsets = Insets.Left + Insets.Right;
var verticalInsets = Insets.Top + Insets.Bottom;
// consider fix insets
double x = availableRect.MinX + (availableRect.Width > horizontalInsets ? Insets.Left : 0);
double y = availableRect.MinY + (availableRect.Height > verticalInsets ? Insets.Top : 0);
double width = availableRect.Width - (availableRect.Width > horizontalInsets ? horizontalInsets : 0);
double height = availableRect.Height - (availableRect.Height > verticalInsets ? verticalInsets : 0);
// consider scaling insets
x += scalingParameter.ScalingInsets.Left * width;
y += scalingParameter.ScalingInsets.Top * height;
width = width * (1 - scalingParameter.ScalingInsets.Left - scalingParameter.ScalingInsets.Right);
height = height * (1 - scalingParameter.ScalingInsets.Top - scalingParameter.ScalingInsets.Bottom);
if (scalingParameter.KeepRatio)
{
var fixRatio = scalingParameter.Ratio;
var availableRatio = height > 0 && width > 0 ? width / height : 1;
if (fixRatio > availableRatio)
{
// keep width
double cy = y + height / 2;
height *= availableRatio / fixRatio;
y = cy - height / 2;
}
else
{
double cx = x + width / 2;
width *= fixRatio / availableRatio;
x = cx - width / 2;
}
}
dummyNode.Layout = new RectD(x, y, width, height);
dummyLabel.PreferredSize = label.PreferredSize;
return(stretchModel.GetGeometry(dummyLabel, stretchParameter));
}
/// <summary>
/// Copy one node label.
/// </summary>
/// <param name="pageView">The view (i.e. target) graph.</param>
/// <param name="nodeLabelLayout">The layout of the label.</param>
/// <param name="modelLabel">The model (i.e. original) label.</param>
/// <param name="layoutNode">The node in the layout graph. </param>
/// <param name="viewNode">The node in the view graph.</param>
/// <returns>The copied label.</returns>
private ILabel CopyNodeLabel(IGraph pageView, INodeLabelLayout nodeLabelLayout, ILabel modelLabel, Node layoutNode, INode viewNode)
{
INodeInfo nodeInfo = result.GetNodeInfo(layoutNode);
ILabelDefaults labelDefaults;
// determine the style for the label
switch (nodeInfo.Type)
{
case NodeType.Group:
labelDefaults = GroupNodeDefaults.Labels;
break;
case NodeType.Connector:
labelDefaults = ConnectorNodeDefaults.Labels;
break;
case NodeType.Proxy:
labelDefaults = ProxyNodeDefaults.Labels;
break;
case NodeType.ProxyReference:
labelDefaults = ProxyReferenceNodeDefaults.Labels;
break;
default:
labelDefaults = NormalNodeDefaults.Labels;
break;
}
ILabelModelParameter parameter = labelDefaults.LayoutParameter != NullLabelModelParameter
? labelDefaults.GetLayoutParameterInstance(viewNode)
: (ILabelModelParameter)nodeLabelLayout.ModelParameter;
ILabelStyle style = labelDefaults.Style != NullLabelStyle
? labelDefaults.GetStyleInstance(viewNode)
: (ILabelStyle)(modelLabel != null ? modelLabel.Style.Clone() : pageView.NodeDefaults.Labels.Style);
string text = modelLabel != null ? modelLabel.Text : null;
object tag = modelLabel != null ? modelLabel.Tag : null;
// create a new label in the view graph using the style,
// the text and tag from the original label and the layout from the layout graph
ILabel viewLabel = pageView.AddLabel(viewNode, text, parameter, style);
viewLabel.Tag = tag;
return(viewLabel);
}
/// <summary>
/// Copy one edge label.
/// </summary>
/// <param name="pageView">The view (i.e. target) graph.</param>
/// <param name="edgeLabelLayout">The layout of the label.</param>
/// <param name="modelLabel">The original label.</param>
/// <param name="viewEdge">The copied edge (from the view graph).</param>
/// <param name="labelDefaults"></param>
/// <returns>The copied label.</returns>
private ILabel CopyEdgeLabel(IGraph pageView, IEdgeLabelLayout edgeLabelLayout, ILabel modelLabel, IEdge viewEdge, ILabelDefaults labelDefaults)
{
// get the style from edgeLabelStyle property. If none is set get it from the original (model) label.
ILabelStyle style = (ILabelStyle)(labelDefaults.Style != NullLabelStyle ?
labelDefaults.GetStyleInstance(viewEdge) :
modelLabel.Style.Clone());
ILabelModelParameter parameter = labelDefaults.LayoutParameter != NullLabelModelParameter
? labelDefaults.GetLayoutParameterInstance(viewEdge)
: (ILabelModelParameter)edgeLabelLayout.ModelParameter;
// create a new label in the view graph using the style,
// the text from the original label and the layout from the layout graph
ILabel viewLabel = pageView.AddLabel(viewEdge, modelLabel.Text, parameter, style);
viewLabel.Tag = modelLabel.Tag;
return(viewLabel);
}
/// <summary>
/// Create a proxy reference node, i.e., a node referencing a proxy node.
/// </summary>
/// <remarks>
/// This implementation copies the labels of the represented node and applies the <c>ProxyReferenceNodeStyle</c>.
/// </remarks>
/// <param name="pageLayoutGraph">The layout graph representing the current page</param>
/// <param name="layoutNode">The node of the layout graph that should be copied</param>
/// <param name="pageView">The <see cref="IGraph"/> that is built to show the multi-page layout in a graph canvas</param>
/// <returns>The created node</returns>
/// <seealso cref="CreateNodeCore"/>
protected INode CreateProxyReferenceNode(LayoutGraph pageLayoutGraph, Node layoutNode, IGraph pageView)
{
INode representedNode = GetRepresentedNode(layoutNode);
INode viewNode = CreateNodeCore(pageLayoutGraph, pageView, layoutNode, representedNode, true, ProxyReferenceNodeDefaults);
INodeInfo nodeInfo = result.GetNodeInfo(layoutNode);
Node referencingNode = nodeInfo.ReferencingNode;
int targetPage = result.GetNodeInfo(referencingNode).PageNo;
ILabelStyle style = ProxyNodeDefaults.Labels.Style != NullLabelStyle
? ProxyNodeDefaults.Labels.GetStyleInstance(viewNode)
: pageView.NodeDefaults.Labels.GetStyleInstance(viewNode);
ILabelModelParameter parameter = ProxyNodeDefaults.Labels.LayoutParameter != NullLabelModelParameter
? ProxyNodeDefaults.Labels.GetLayoutParameterInstance(viewNode)
: pageView.NodeDefaults.Labels.GetLayoutParameterInstance(viewNode);
pageView.AddLabel(viewNode, "p" + targetPage, parameter, style);
return(viewNode);
}
public IOrientedRectangle GetGeometry(ILabel label, ILabelModelParameter parameter)
{
var php = parameter as PoolHeaderParameter;
INode owner = (INode)label.Owner;
if (php == null || owner == null)
{
return(null);
}
ITable table = owner.Lookup <ITable>();
InsetsD insets = table != null && table.Insets != InsetsD.Empty ? table.Insets : new InsetsD(0);
var orientedRectangle = new OrientedRectangle();
orientedRectangle.Resize(label.PreferredSize);
switch (php.Side)
{
case 0: // North
orientedRectangle.SetUpVector(0, -1);
orientedRectangle.SetCenter(new PointD(owner.Layout.X + owner.Layout.Width / 2, owner.Layout.Y + insets.Top / 2));
break;
case 1: // East
orientedRectangle.SetUpVector(1, 0);
orientedRectangle.SetCenter(new PointD(owner.Layout.GetMaxX() - insets.Right / 2, owner.Layout.Y + owner.Layout.Height / 2));
break;
case 2: // South
orientedRectangle.SetUpVector(0, -1);
orientedRectangle.SetCenter(new PointD(owner.Layout.X + owner.Layout.Width / 2, owner.Layout.GetMaxY() - insets.Bottom / 2));
break;
case 3: // West
default:
orientedRectangle.SetUpVector(-1, 0);
orientedRectangle.SetCenter(new PointD(owner.Layout.X + insets.Left / 2, owner.Layout.Y + owner.Layout.Height / 2));
break;
}
return(orientedRectangle);
}
/// <summary>
/// Returns the current geometry of the given label.
/// </summary>
public IOrientedRectangle GetGeometry(ILabel label, ILabelModelParameter parameter)
{
var styleWrapper = GetNodeStyleWrapper(label);
var wrappedParameter = GetWrappedParameter(parameter);
var orientedRectangle = wrappedParameter.Model.GetGeometry(label, wrappedParameter);
var node = label.Owner as INode;
if (!UseNodeRotation || node == null || styleWrapper == null || styleWrapper.Angle == 0)
{
return(orientedRectangle);
}
var rotatedCenter = styleWrapper.GetRotatedPoint(orientedRectangle.GetCenter(), node, true);
var rotatedLayout = styleWrapper.GetRotatedLayout(node);
var rectangle = new OrientedRectangle(orientedRectangle);
rectangle.Angle += rotatedLayout.GetRadians();
rectangle.SetCenter(rotatedCenter);
return(rectangle);
}
///<inheritdoc/>
public IOrientedRectangle GetGeometry(ILabel label, ILabelModelParameter parameter)
{
OrientedRectangle geometry = new OrientedRectangle(0, 0, 10, 10);
IEdge edge = (IEdge)label.Owner;
if (edge == null)
{
geometry.Width = -1;
geometry.Height = -1;
return(geometry);
}
SliderParameter sliderParameter = (SliderParameter)parameter;
SizeD preferredSize = label.PreferredSize;
geometry.Width = preferredSize.Width;
geometry.Height = preferredSize.Height;
geometry.SetUpVector(upX, upY);
sliderParameter.SetAnchor(this, edge, geometry);
return(geometry);
}
public ChoreographyMessageLabelStyleExtension()
{
TextPlacement = ChoreographyMessageLabelStyle.defaultTextPlacement;
}
/// <inheritdoc/>
public virtual ILookup GetContext(ILabel label, ILabelModelParameter parameter)
{
return(Lookups.Empty);
}
/// <summary>
/// Initializes a new instance of the <see cref="RotatedSideSliderEdgeLabelModel"/> class.
/// </summary>
/// <param name="innerParameter">The wrapped parameter.</param>
/// <param name="labelModel">The label model.</param>
internal RotatedSideSliderParameter(ILabelModelParameter innerParameter, RotatedSideSliderEdgeLabelModel labelModel)
{
this.InnerParameter = innerParameter;
this.labelModel = labelModel;
}
/// <summary>
/// Creates a new instance wrapping the given parameter.
/// </summary>
public RotatableNodeLabelModelDecoratorParameter(ILabelModelParameter wrapped, ILabelModel model)
{
Wrapped = wrapped;
Model = model;
}
/// <summary>
/// Returns the wrapped label model parameter.
/// </summary>
private ILabelModelParameter GetWrappedParameter(ILabelModelParameter parameter)
{
return(((RotatableNodeLabelModelDecoratorParameter)parameter).Wrapped);
}
/// <summary>
/// Provides a lookup context for the given combination of label and parameter.
/// </summary>
public ILookup GetContext(ILabel label, ILabelModelParameter parameter)
{
var wrappedParameter = GetWrappedParameter(parameter);
return(wrappedParameter.Model.GetContext(label, wrappedParameter));
}
/// <summary>
/// Creates a new parameter wrapping <paramref name="wrapped"/>.
/// </summary>
/// <remarks>The label model of <paramref name="wrapped"/> should be the same as <see cref="Wrapped"/>.</remarks>
/// <param name="wrapped">The parameter to wrap.</param>
/// <returns>A parameter wrapping <paramref name="wrapped"/>.</returns>
public ILabelModelParameter CreateWrappingParameter(ILabelModelParameter wrapped)
{
return(new RotatableNodeLabelModelDecoratorParameter(wrapped, this));
}
public ILookup GetContext(ILabel label, ILabelModelParameter parameter)
{
return(InteriorLabelModel.Center.Model.GetContext(label, parameter));
}
///<inheritdoc/>
public ILookup GetContext(ILabel label, ILabelModelParameter parameter)
{
return(stretchModel.GetContext(label, parameter));
}
