internal virtual void MatchWay(RenderCallback renderCallback, PolylineContainer way, Tile tile, Closed closed, IList <RenderInstruction> matchingList, RenderContext renderContext)
{
if (MatchesWay(way.Tags, tile.ZoomLevel, closed))
{
for (int i = 0, n = this.renderInstructions.Count; i < n; ++i)
{
this.renderInstructions[i].RenderWay(renderCallback, renderContext, way);
matchingList.Add(this.renderInstructions[i]);
}
for (int i = 0, n = this.subRules.Count; i < n; ++i)
{
this.subRules[i].MatchWay(renderCallback, way, tile, closed, matchingList, renderContext);
}
}
}
public override void RenderWay(RenderCallback renderCallback, RenderContext renderContext, PolylineContainer way)
{
lock (this)
{
if (!bitmapCreated)
{
try
{
shaderBitmap = CreateBitmap(relativePathPrefix, src);
}
catch (IOException)
{
// no-op
}
bitmapCreated = true;
}
IPaint strokePaint = getStrokePaint(renderContext.rendererJob.tile.ZoomLevel);
if (shaderBitmap != null)
{
strokePaint.BitmapShader = shaderBitmap;
strokePaint.SetBitmapShaderShift = way.Tile.Origin;
}
float dyScale = this.dyScaled[renderContext.rendererJob.tile.ZoomLevel] ?? this.dy;
renderCallback.RenderWay(renderContext, strokePaint, dyScale, this.level, way);
}
}
public override void RenderWay(RenderCallback renderCallback, RenderContext renderContext, PolylineContainer way)
{
if (Display.NEVER == this.display)
{
return;
}
if (this.Bitmap != null)
{
renderCallback.RenderAreaSymbol(renderContext, this.display, this.priority, this.bitmap, way);
}
}
/// <param name="renderCallback"> /// a reference to the receiver of all render callbacks. </param> /// <param name="renderContext"> </param> /// <param name="way"> </param> public abstract void RenderWay(RenderCallback renderCallback, RenderContext renderContext, PolylineContainer way);
public override void RenderWay(RenderCallback renderCallback, RenderContext renderContext, PolylineContainer way)
{
if (Display.Never == this.display)
{
return;
}
string caption = this.textKey.GetValue(way.Tags);
if (string.ReferenceEquals(caption, null))
{
return;
}
float horizontalOffset = 0f;
float verticalOffset = this.dyScaled[renderContext.rendererJob.tile.ZoomLevel] ?? this.dy;
if (this.bitmap != null)
{
horizontalOffset = ComputeHorizontalOffset();
verticalOffset = ComputeVerticalOffset(renderContext.rendererJob.tile.ZoomLevel);
}
renderCallback.RenderAreaCaption(renderContext, this.display, this.priority, caption, horizontalOffset, verticalOffset, getFillPaint(renderContext.rendererJob.tile.ZoomLevel), getStrokePaint(renderContext.rendererJob.tile.ZoomLevel), this.position, this.maxTextWidth, way);
}
public override void RenderWay(RenderCallback renderCallback, RenderContext renderContext, PolylineContainer way)
{
if (Display.Never == this.display)
{
return;
}
string caption = this.textKey.GetValue(way.Tags);
if (string.ReferenceEquals(caption, null))
{
return;
}
float dyScale = this.dyScaled[renderContext.rendererJob.tile.ZoomLevel] ?? this.dy;
renderCallback.RenderWayText(renderContext, this.display, this.priority, caption, dyScale, GetFillPaint(renderContext.rendererJob.tile.ZoomLevel), getStrokePaint(renderContext.rendererJob.tile.ZoomLevel), way);
}
public override void RenderWay(RenderCallback renderCallback, RenderContext renderContext, PolylineContainer way)
{
// do nothing
}
public override void RenderWay(RenderCallback renderCallback, RenderContext renderContext, PolylineContainer way)
{
lock (this)
{
// this needs to be synchronized as we potentially set a shift in the shader and
// the shift is particular to the tile when rendered in multi-thread mode
IPaint fillPaint = getFillPaint(renderContext.rendererJob.tile.ZoomLevel);
if (shaderBitmap == null && !bitmapInvalid)
{
try
{
shaderBitmap = CreateBitmap(relativePathPrefix, src);
if (shaderBitmap != null)
{
fillPaint.BitmapShader = shaderBitmap;
shaderBitmap.DecrementRefCount();
}
}
catch (IOException)
{
bitmapInvalid = true;
}
}
fillPaint.BitmapShaderShift = way.Tile.Origin;
renderCallback.RenderArea(renderContext, fillPaint, getStrokePaint(renderContext.rendererJob.tile.ZoomLevel), this.level, way);
}
}
private void MatchWay(RenderCallback renderCallback, RenderContext renderContext, Closed closed, PolylineContainer way)
{
lock (this)
{
MatchingCacheKey matchingCacheKey = new MatchingCacheKey(way.Tags, way.Tile.ZoomLevel, closed);
IList <RenderInstruction> matchingList = this.wayMatchingCache.Get(matchingCacheKey);
if (matchingList != null)
{
// cache hit
for (int i = 0, n = matchingList.Count; i < n; ++i)
{
matchingList[i].RenderWay(renderCallback, renderContext, way);
}
return;
}
// cache miss
matchingList = new List <RenderInstruction>();
for (int i = 0, n = this.rulesList.Count; i < n; ++i)
{
this.rulesList[i].MatchWay(renderCallback, way, way.Tile, closed, matchingList, renderContext);
}
this.wayMatchingCache.Add(matchingCacheKey, matchingList);
}
}
/// <summary>
/// Matches a linear way with the given parameters against this RenderTheme. </summary>
/// <param name="renderCallback">
/// the callback implementation which will be executed on each match. </param>
/// <param name="renderContext"> </param>
/// <param name="way"> </param>
public virtual void MatchLinearWay(RenderCallback renderCallback, RenderContext renderContext, PolylineContainer way)
{
MatchWay(renderCallback, renderContext, Closed.NO, way);
}
public override void RenderWay(RenderCallback renderCallback, RenderContext renderContext, PolylineContainer way)
{
if (Display.NEVER == this.display)
{
return;
}
if (this.bitmap == null && !this.bitmapInvalid)
{
try
{
this.bitmap = CreateBitmap(relativePathPrefix, src);
}
catch (IOException)
{
this.bitmapInvalid = true;
}
}
float dyScale = this.dyScaled[renderContext.rendererJob.tile.ZoomLevel] ?? this.dy;
if (this.bitmap != null)
{
renderCallback.RenderWaySymbol(renderContext, this.display, this.priority, this.bitmap, dyScale, this.alignCenter, this.repeat, this.repeatGap, this.repeatStart, this.rotate, way);
}
}
