public SideSliderParameter(SideSliderEdgeLabelModel model, SliderParameterLocation location,
ILabelModelParameter parameter)
{
this.model = model;
this.location = location;
this.parameter = parameter;
}
/// <summary>
/// Builds the properties for the labels's <see cref="ILabelModel"/> type.
/// </summary>
protected virtual void BuildModelProperties(IPropertyBuildContext <ILabel> context)
{
ValueGetterDelegate <Type> labelModelGetter = new ValueGetterDelegate <Type>(
delegate {
var type = context.CurrentInstance.LayoutParameter.Model.GetType();
while (!type.IsPublic)
{
type = type.BaseType;
}
return(type);
});
ValueSetterDelegate <Type> labelModelSetter = new ValueSetterDelegate <Type>(
delegate(Type value) {
IGraph graph = context.Lookup(typeof(IGraph)) as IGraph;
if (graph != null)
{
ILabelModel model = Activator.CreateInstance(value) as ILabelModel;
if (model != null)
{
ILabelModelParameterFinder finder =
model.Lookup(typeof(ILabelModelParameterFinder)) as ILabelModelParameterFinder;
ILabelModelParameter parameter;
ILabel subject = context.CurrentInstance;
if (finder != null)
{
parameter = finder.FindBestParameter(subject, model, subject.GetLayout());
}
else
{
parameter = model.CreateDefaultParameter();
}
graph.SetLabelLayoutParameter(subject, parameter);
}
}
});
ILabel currentLabel;
currentLabel = context.CurrentInstance;
if (currentLabel == null)
{
return;
}
if (currentLabel.Owner is IEdge)
{
context.AddEntry(EdgeLabelModelProperty,
labelModelGetter,
labelModelSetter, null);
}
if (currentLabel.Owner is INode)
{
context.AddEntry(NodeLabelModelProperty, labelModelGetter, labelModelSetter, null);
}
if (currentLabel.Owner is IPort)
{
context.AddEntry(PortLabelModelProperty, labelModelGetter, labelModelSetter, null);
}
}
/// <summary>
/// Returns a set of possible wrapped <see cref="ILabelModelParameter"/> instances.
/// </summary>
public IEnumerable <ILabelModelParameter> GetParameters(ILabel label, ILabelModel model)
{
var wrapperModel = model as RotatableNodeLabelModelDecorator;
var parameters = wrappedProvider.GetParameters(label, wrapperModel.Wrapped);
var result = new List <ILabelModelParameter>();
foreach (var parameter in parameters)
{
result.Add(wrapperModel.CreateWrappingParameter(parameter));
}
return(result);
}
///<inheritdoc/>
public IEnumerable <ILabelModelParameter> GetParameters(ILabel label, ILabelModel model)
{
List <ILabelModelParameter> parameters = new List <ILabelModelParameter>();
RotatedSideSliderEdgeLabelModel rotatedModel;
var rotatedSideSliderEdgeLabelModel = model as RotatedSideSliderEdgeLabelModel;
if (rotatedSideSliderEdgeLabelModel != null)
{
rotatedModel = rotatedSideSliderEdgeLabelModel;
}
else
{
rotatedModel = this;
}
var rightModel = rotatedModel.rightModel;
var leftModel = rotatedModel.leftModel;
if (rightModel != null)
{
var parameterProvider = (ILabelModelParameterProvider)rightModel.Lookup(typeof(ILabelModelParameterProvider));
if (parameterProvider != null)
{
var innerParameters = parameterProvider.GetParameters(label, rightModel);
foreach (var innerParameter in innerParameters)
{
parameters.Add(new RotatedSideSliderParameter(innerParameter, rotatedModel));
}
}
}
if (leftModel != null)
{
var parameterProvider = (ILabelModelParameterProvider)leftModel.Lookup(typeof(ILabelModelParameterProvider));
if (parameterProvider != null)
{
var innerParameters = parameterProvider.GetParameters(label, leftModel);
foreach (var innerParameter in innerParameters)
{
parameters.Add(new RotatedSideSliderParameter(innerParameter, rotatedModel));
}
}
}
return(parameters);
}
/// <inheritdoc/>
public IEnumerable <ILabelModelParameter> GetParameters(ILabel label, ILabelModel model)
{
SideSliderEdgeLabelModel mmodel = (SideSliderEdgeLabelModel)model;
List <ILabelModelParameter> list = new List <ILabelModelParameter>();
foreach (
SliderEdgeLabelModel.SliderParameter parameter in mmodel.leftSlider.GetParameters(label, mmodel.leftSlider))
{
list.Add(new SideSliderParameter(this,
SliderParameterLocation.Left |
(parameter.segmentIndex >= 0 ? SliderParameterLocation.FromSource : SliderParameterLocation.FromTarget),
parameter));
}
foreach (
SliderEdgeLabelModel.SliderParameter parameter in mmodel.rightSlider.GetParameters(label, mmodel.rightSlider))
{
list.Add(new SideSliderParameter(this,
SliderParameterLocation.Right |
(parameter.segmentIndex >= 0 ? SliderParameterLocation.FromSource : SliderParameterLocation.FromTarget),
parameter));
}
return(list);
}
public IEnumerable <ILabelModelParameter> GetParameters(ILabel label, ILabelModel model)
{
var parameters = new List <ILabelModelParameter>();
var node = label.Owner as INode;
if (node != null && node.Style is ChoreographyNodeStyle)
{
var nodeStyle = (ChoreographyNodeStyle)node.Style;
for (var i = 0; i < nodeStyle.TopParticipants.Count; i++)
{
parameters.Add(CreateParticipantParameter(true, i));
}
parameters.Add(TaskNameBand);
for (var i = 0; i < nodeStyle.BottomParticipants.Count; i++)
{
parameters.Add(CreateParticipantParameter(false, i));
}
parameters.Add(NorthMessage);
parameters.Add(SouthMessage);
}
return(parameters);
}
/// <summary>
/// Finds the label model parameter that describes the given label layout best.
/// </summary>
/// <remarks>
/// Sometimes the layout cannot be met exactly, then the nearest location is used.
/// </remarks>
public ILabelModelParameter FindBestParameter(ILabel label, ILabelModel model, IOrientedRectangle labelLayout)
{
var wrapperModel = model as RotatableNodeLabelModelDecorator;
var styleWrapper = wrapperModel.GetNodeStyleWrapper(label);
if (!wrapperModel.UseNodeRotation || styleWrapper == null || styleWrapper.Angle == 0)
{
return
(wrapperModel.CreateWrappingParameter(wrappedFinder.FindBestParameter(label, wrapperModel.Wrapped,
labelLayout)));
}
var node = label.Owner as INode;
var rotatedCenter = styleWrapper.GetRotatedPoint(labelLayout.GetCenter(), node, false);
var rotatedLayout = styleWrapper.GetRotatedLayout(node);
var rectangle = new OrientedRectangle(labelLayout);
rectangle.Angle -= rotatedLayout.GetRadians();
rectangle.SetCenter(rotatedCenter);
return
(wrapperModel.CreateWrappingParameter(wrappedFinder.FindBestParameter(label, wrapperModel.Wrapped, rectangle)));
}
/// <summary>
/// Does the label placement using the generic labeling algorithm. Before this, the model and size of the labels is
/// set according to the option handlers settings.
/// </summary>
private async Task DoLabelPlacement()
{
if (inLayout)
{
return;
}
inLayout = true;
toolStrip.Enabled = false;
//desired label model
ILabelModel labelModel = LabelModels[labelModelComboBox.SelectedItem.ToString()];
//desired label size
int size = Convert.ToInt32(sizeNumericUpDown.NumericUpDownControl.Text);
foreach (var label in graphControl.Graph.Labels)
{
if (label.Owner is INode)
{
// only update the label model parameter if the label model changed
if (labelModel != graphControl.Graph.NodeDefaults.Labels.LayoutParameter.Model)
{
graphControl.Graph.SetLabelLayoutParameter(label, labelModel.CreateDefaultParameter());
}
var cityLabelStyle = label.Style as CityLabelStyle;
if (cityLabelStyle != null && cityLabelStyle.InnerLabelStyle is DefaultLabelStyle)
{
var font = ((DefaultLabelStyle)cityLabelStyle.InnerLabelStyle).Font;
((DefaultLabelStyle)cityLabelStyle.InnerLabelStyle).Font = new Font(font.FontFamily, size);
}
graphControl.Graph.AdjustLabelPreferredSize(label);
}
}
{
// set as default label model parameter
graphControl.Graph.NodeDefaults.Labels.LayoutParameter = labelModel.CreateDefaultParameter();
var cityLabelStyle = graphControl.Graph.NodeDefaults.Labels.Style as CityLabelStyle;
if (cityLabelStyle != null && cityLabelStyle.InnerLabelStyle is DefaultLabelStyle)
{
var font = ((DefaultLabelStyle)cityLabelStyle.InnerLabelStyle).Font;
((DefaultLabelStyle)cityLabelStyle.InnerLabelStyle).Font = new Font(font.FontFamily, size);
}
}
graphControl.Invalidate();
// configure and run the layout algorithm
var labelingAlgorithm = new GenericLabeling
{
MaximumDuration = 0,
OptimizationStrategy = OptimizationStrategy.Balanced,
PlaceEdgeLabels = false,
PlaceNodeLabels = true,
ReduceLabelOverlaps = true,
ProfitModel = new ExtendedLabelCandidateProfitModel(),
};
var layoutExecutor = new LayoutExecutor(graphControl, graphControl.Graph, labelingAlgorithm)
{
Duration = TimeSpan.FromMilliseconds(500),
EasedAnimation = true,
AnimateViewport = false,
UpdateContentRect = true
};
await layoutExecutor.Start();
toolStrip.Enabled = true;
inLayout = false;
}
/// <summary>
/// Retrieves the <see cref="IOptionBuilder"/> to use for the label model of the provided label.
/// </summary>
/// <remarks>
/// This implementation simply delegates to <see cref="IOptionBuilderContext.GetOptionBuilder(object)"/>.
/// </remarks>
/// <param name="context">The context to use.</param>
/// <param name="model">The current model instance.</param>
/// <returns>The builder or <see langword="null"/>.</returns>
protected virtual IOptionBuilder GetLabelModelOptionBuilder(IOptionBuilderContext context, ILabelModel model)
{
return(context.GetOptionBuilder(model));
}
/// <summary>
/// Does the label placement using the generic labeling algorithm. Before this, the model and size of the labels is
/// set according to the option handlers settings.
/// </summary>
private async Task DoLabelPlacement()
{
if (inLayout)
{
return;
}
inLayout = true;
toolBar.IsEnabled = false;
editorControl.IsEnabled = false;
//desired label model
ILabelModel labelModel = LabelModels[(string)handler[LABEL_MODEL].Value];
int size = (int)handler[LABEL_SIZE].Value;
foreach (var label in graphControl.Graph.Labels)
{
if (label.Owner is INode)
{
// only update the label model parameter if the label model changed
if (labelModel != graphControl.Graph.NodeDefaults.Labels.LayoutParameter.Model)
{
graphControl.Graph.SetLabelLayoutParameter(label, labelModel.CreateDefaultParameter());
}
var cityLabelStyle = label.Style as CityLabelStyle;
if (cityLabelStyle != null && cityLabelStyle.InnerLabelStyle is DefaultLabelStyle)
{
((DefaultLabelStyle)cityLabelStyle.InnerLabelStyle).TextSize = size;
}
graphControl.Graph.AdjustLabelPreferredSize(label);
}
}
{
// set as default label model parameter
graphControl.Graph.NodeDefaults.Labels.LayoutParameter = labelModel.CreateDefaultParameter();
var cityLabelStyle = graphControl.Graph.NodeDefaults.Labels.Style as CityLabelStyle;
if (cityLabelStyle != null && cityLabelStyle.InnerLabelStyle is DefaultLabelStyle)
{
((DefaultLabelStyle)cityLabelStyle.InnerLabelStyle).TextSize = size;
}
}
graphControl.Invalidate();
// configure and run the layout algorithm
var labelingAlgorithm = new GenericLabeling
{
MaximumDuration = 0,
OptimizationStrategy = OptimizationStrategy.Balanced,
PlaceEdgeLabels = false,
PlaceNodeLabels = true,
ReduceLabelOverlaps = true,
ProfitModel = new ExtendedLabelCandidateProfitModel(),
};
var layoutExecutor = new LayoutExecutor(graphControl, graphControl.Graph, labelingAlgorithm)
{
Duration = TimeSpan.FromMilliseconds(500),
EasedAnimation = true,
AnimateViewport = false,
UpdateContentRect = true
};
await layoutExecutor.Start();
toolBar.IsEnabled = true;
editorControl.IsEnabled = true;
inLayout = false;
}
/// <summary>
/// Creates a new instance for the passed model.
/// </summary>
/// <param name="wrapped">The label model to wrap.</param>
public RotatableNodeLabelModelDecorator(ILabelModel wrapped)
{
this.Wrapped = wrapped;
UseNodeRotation = true;
}
/// <summary>
/// Retrieves the builder for the given label model.
/// </summary>
protected virtual IPropertyMapBuilder GetLabelModelPropertyMapBuilder(IPropertyBuildContext <ILabel> context, ILabelModel model)
{
return(context.GetPropertyMapBuilder(model));
}
/// <summary>
/// Creates a new instance wrapping the given parameter.
/// </summary>
public RotatableNodeLabelModelDecoratorParameter(ILabelModelParameter wrapped, ILabelModel model)
{
Wrapped = wrapped;
Model = model;
}
ILabelModelParameter ILabelModelParameterFinder.FindBestParameter(ILabel label, ILabelModel model,
IOrientedRectangle labelLayout)
{
var leftParam = ((ILabelModelParameterFinder)leftModel).FindBestParameter(label, leftModel, labelLayout);
var rightParam = ((ILabelModelParameterFinder)rightModel).FindBestParameter(label, rightModel, labelLayout);
var leftGeom = ((ILabelModel)leftModel).GetGeometry(label, leftParam);
var rightGeom = ((ILabelModel)rightModel).GetGeometry(label, rightParam);
var layoutCenter = labelLayout.GetCenter();
double leftDist = leftGeom.GetCenter().DistanceTo(layoutCenter);
double rightDist = rightGeom.GetCenter().DistanceTo(layoutCenter);
return(leftDist < rightDist
? new RotatedSideSliderParameter(leftParam, this)
: new RotatedSideSliderParameter(rightParam, this));
}
/// <summary>
/// Returns possible parameters for the given label and model.
/// </summary>
/// <param name="label">The label for which to retrieve the parameters</param>
/// <param name="model"> must be <c>this</c> or at least of this type.</param>
public virtual IEnumerable <ILabelModelParameter> GetParameters(ILabel label, ILabelModel model)
{
RotatingEdgeLabelModel rotatingEdgeLabelModel = (RotatingEdgeLabelModel)model;
List <ILabelModelParameter> candidates = new List <ILabelModelParameter>();
for (int i = 0; i <= 10; i++)
{
candidates.Add(new RatioParameter(rotatingEdgeLabelModel, i * 0.1));
}
return(candidates);
}
/// <summary>
/// Tries to find a parameter that best matches the given layout for the
/// provided label instance.
/// </summary>
/// <remarks>By default, this method is only called when <b>no discrete</b> candidates are specified (i.e. here for <see cref="CandidateCount"/> = 0.
/// This implementation just calculates the rotation angle for the center of <paramref name="labelLayout"/>
/// and creates a parameter for exactly this angle which <see cref="CreateParameter"/>.</remarks>
ILabelModelParameter ILabelModelParameterFinder.FindBestParameter(ILabel label, ILabelModel model, IOrientedRectangle labelLayout)
{
var labelModel = model as MyNodeLabelModel;
var node = label.Owner as INode;
if (labelModel != null && node != null)
{
var direction = (labelLayout.GetCenter() - node.Layout.GetCenter()).Normalized;
double ratio = Math.Atan2(direction.Y, -direction.X) / (Math.PI * 2.0d);
return(labelModel.CreateParameter(ratio));
}
else
{
return(DefaultLabelModelParameterFinder.Instance.FindBestParameter(label, model, labelLayout));
}
}
/// <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);
}
///<inheritdoc/>
public virtual IEnumerable <ILabelModelParameter> GetParameters(ILabel label, ILabelModel model)
{
SliderEdgeLabelModel sliderEdgeLabelModel = (SliderEdgeLabelModel)model;
List <ILabelModelParameter> result = new List <ILabelModelParameter>();
IEdge edge = (IEdge)label.Owner;
IPathGeometry geometry = GetPathGeometry(edge);
if (geometry != null)
{
int count = geometry.GetSegmentCount();
for (int i = 0; i < count; i++)
{
result.Add(sliderEdgeLabelModel.CreateParameterFromSource(i, 0));
result.Add(sliderEdgeLabelModel.CreateParameterFromSource(i, 0.5));
result.Add(sliderEdgeLabelModel.CreateParameterFromSource(i, 1));
}
}
return(result);
}
private static void SetPreferredSide(PreferredPlacementDescriptor newDescriptor,
PreferredPlacementDescriptor oldDescriptor, ILabelModel model)
{
if (model is EdgeSegmentLabelModel)
{
var rotatedModel = model as EdgeSegmentLabelModel;
var onEdge = (rotatedModel.SideOfEdge & EdgeSides.OnEdge) == EdgeSides.OnEdge;
newDescriptor.SideOfEdge = onEdge ? LabelPlacements.OnEdge : LabelPlacements.RightOfEdge | LabelPlacements.LeftOfEdge;
newDescriptor.DistanceToEdge = rotatedModel.Distance;
}
}
public IEnumerable <ILabelModelParameter> GetParameters(ILabel label, ILabelModel model)
{
return(parameters);
}
