/// <summary>
/// This ensures nested image refs get defined when displaying only part of file
/// </summary>
/// <param name="defs"></param>
/// <param name="isRoot"></param>
public void AddImagesPart(Dictionary <uint, IDefinition> defs, bool isRoot)
{
uint imgCount = 0;
foreach (uint key in defs.Keys)
{
IDefinition def = defs[key];
if (defs[key] is Symbol)
{
Symbol sym = (Symbol)defs[key];
for (int i = 0; i < sym.Shapes.Count; i++)
{
Shape sh = sym.Shapes[i];
if (sh.Fill is ImageFill)
{
ImageFill imf = (ImageFill)sh.Fill;
Image img = new Image(imf.ImagePath, imgCount++);
string brushName = imageBrushPrefix + img.Id.ToString();
xw.WriteImageBrushRef(brushName, img.Path);
imageBrushes.Add(img.Path, brushName);
images.Add(img.Path, img);
}
}
}
}
}
public override void Metamorphose(LegoUIMeta uiMeta)
{
if (MetamorphoseStage == LegoMetamorphoseStage.Completed)
{
MetamorphoseStage = LegoMetamorphoseStage.Metamorphosing;
}
if (progressbarMeta == null)
{
progressbarMeta = uiMeta.NextProgressbar;
RectMeta = uiMeta.CurrentRect;
}
switch (progressbarStatus)
{
case YuProgressbarMetamorphoseStatus.Progressbar:
MetamorphoseRect(RectMeta);
progressbarStatus = YuProgressbarMetamorphoseStatus.ImageBackground;
break;
case YuProgressbarMetamorphoseStatus.ImageBackground:
ImageBackground.Metamorphose(progressbarMeta.BackgroundImageRect,
progressbarMeta.BackgroundImageMeta);
progressbarStatus = YuProgressbarMetamorphoseStatus.RectTransform_FillArea;
break;
case YuProgressbarMetamorphoseStatus.RectTransform_FillArea:
YuLegoUtility.MetamorphoseRect(RectFillArea, progressbarMeta.FillAreaMeta);
progressbarStatus = YuProgressbarMetamorphoseStatus.Image_Fill;
break;
case YuProgressbarMetamorphoseStatus.Image_Fill:
ImageFill.Metamorphose(progressbarMeta.FillImageRect,
progressbarMeta.FillImageMeta);
progressbarMeta = null;
progressbarStatus = YuProgressbarMetamorphoseStatus.Progressbar;
MetamorphoseStage = LegoMetamorphoseStage.Completed;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
static void Main(string[] args)
{
var faded = new FadeMethods();
faded.Setup();
faded.flafla2();
faded.Vector1();
var image = new ImageFill();
image.GlobalSetup();
image.IterationSetup();
image.OriginalGenerator();
image.NewGenerator();
//var summary1 = BenchmarkRunner.Run<FadeMethods>();
var summary2 = BenchmarkRunner.Run <ImageFill>();
}
public override void Metamorphose(LegoUIMeta uiMeta)
{
if (MetamorphoseStage == LegoMetamorphoseStage.Completed)
{
MetamorphoseStage = LegoMetamorphoseStage.Metamorphosing;
}
if (sliderMeta == null)
{
sliderMeta = uiMeta.NextSlider;
RectMeta = uiMeta.CurrentRect;
}
switch (metamorphoseStatus)
{
case YuLegoSliderMetamorphoseStatus.Slider:
YuLegoUtility.MetamorphoseRect(RectTransform, uiMeta.CurrentRect);
direction = sliderMeta.Direction;
minValue = sliderMeta.MinValue;
maxValue = sliderMeta.MaxValue == 0?1:sliderMeta.MaxValue;
wholeNumbers = sliderMeta.IsWholeNumbers;
if (sliderMeta.Transition == LegoTransition.ColorTint)
{
var colorTintMeta = sliderMeta.ColorTintMeta;
colors = new ColorBlock
{
normalColor = colorTintMeta.NormalLegoColor.ToColor(),
highlightedColor = colorTintMeta.HighlightedLegoColor.ToColor(),
pressedColor = colorTintMeta.PressedLegoColor.ToColor(),
disabledColor = colorTintMeta.DisabledLegoColor.ToColor(),
colorMultiplier = colorTintMeta.ColorMultiplier,
fadeDuration = colorTintMeta.FadeDuration
};
}
metamorphoseStatus = YuLegoSliderMetamorphoseStatus.Image_Background;
break;
case YuLegoSliderMetamorphoseStatus.Image_Background:
ImageBackground.Metamorphose(sliderMeta.BackgroundImageRect,
sliderMeta.BackgroundImageMeta);
metamorphoseStatus = YuLegoSliderMetamorphoseStatus.RectTransform_FillArea;
break;
case YuLegoSliderMetamorphoseStatus.RectTransform_FillArea:
YuLegoUtility.MetamorphoseRect(RectFillArea, sliderMeta.FillAreaMeta);
metamorphoseStatus = YuLegoSliderMetamorphoseStatus.Image_Fill;
break;
case YuLegoSliderMetamorphoseStatus.Image_Fill:
ImageFill.Metamorphose(sliderMeta.FillImageRect, sliderMeta.FillImageMeta);
metamorphoseStatus = YuLegoSliderMetamorphoseStatus.RectTransform_HandleSlideArea;
break;
case YuLegoSliderMetamorphoseStatus.RectTransform_HandleSlideArea:
YuLegoUtility.MetamorphoseRect(HandleSlideArea, sliderMeta.HandleSlideAreaRect);
metamorphoseStatus = YuLegoSliderMetamorphoseStatus.Image_Handle;
break;
case YuLegoSliderMetamorphoseStatus.Image_Handle:
HandleImage.Metamorphose(sliderMeta.HandleImageRect, sliderMeta.HandleImageMeta);
sliderMeta = null;
metamorphoseStatus = YuLegoSliderMetamorphoseStatus.Slider;
MetamorphoseStage = LegoMetamorphoseStage.Completed;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private void FillPaths(FillStyle fill, List <GraphicsPath> paths)
{
Brush b = null;
foreach (GraphicsPath path in paths)
{
path.Transform(translateMatrix);
switch (fill.FillType)
{
case FillType.Solid:
SolidFill sf = (SolidFill)fill;
b = new SolidBrush(GetColor(sf.Color));
break;
case FillType.Linear:
GradientFill lf = (GradientFill)fill;
RectangleF rect = Vex.GradientFill.GradientVexRect.SysRectangleF();
LinearGradientBrush lgb = new LinearGradientBrush(
rect,
Ms.Color.White,
Ms.Color.White,
1.0F
);
lgb.InterpolationColors = GetColorBlend(lf);
lgb.Transform = GetMatrix(lf.Transform);
lgb.WrapMode = WrapMode.TileFlipX;
ExtendGradientBrush(lgb, path);
b = lgb;
break;
case FillType.Radial:
GradientFill rf = (GradientFill)fill;
ColorBlend cb = GetColorBlend(rf);
SolidBrush bkgCol = new SolidBrush(cb.Colors[0]);
g.FillPath(bkgCol, path);
bkgCol.Dispose();
// radial fill part
GraphicsPath gp = new GraphicsPath();
gp.AddEllipse(Vex.GradientFill.GradientVexRect.SysRectangleF());
PathGradientBrush pgb = new PathGradientBrush(gp);
pgb.InterpolationColors = GetColorBlend(rf);
pgb.Transform = GetMatrix(rf.Transform);
b = pgb;
break;
case FillType.Image:
ImageFill imgFill = (ImageFill)fill;
Bitmap bmp = new Bitmap(imgFill.ImagePath);
b = new TextureBrush(bmp);
break;
default:
b = new SolidBrush(Ms.Color.Red);
break;
}
g.FillPath(b, path);
}
if (b != null)
{
b.Dispose();
}
}
protected override void RenderPath(FillStyle fs, StrokeStyle ss, List <IShapeData> sh, bool silverlight)
{
// <Path Fill="#FFFF0000"
// StrokeThickness="0.00491913" StrokeLineJoin="Round" Stroke="#FF014393"
// Data="M 196.667,4L 388.667,100L 388.667,292L 196.667,388L 4.66669,292L 4.66669,100L 196.667,4 Z "/>
if (sh.Count == 0)
{
return;
}
xw.WriteStartElement("Path");
bool isGradient = false;
bool isTiledBitmap = false;
if (fs != null)
{
if (fs.FillType == FillType.Solid)
{
Color c = ((SolidFill)fs).Color;
xw.WriteStartAttribute("Fill");
xw.WriteColor(c);
xw.WriteEndAttribute();
// try to clean up faint edges
if (ss == null && c != new Color(0xFF, 0xFF, 0xFF) && c.A != 0)
{
ss = new SolidStroke(0.3F, c);
}
}
else if (
fs.FillType == FillType.Linear ||
fs.FillType == FillType.Radial ||
fs.FillType == FillType.Focal)
{
isGradient = true;
}
else if (fs.FillType == FillType.Image)
{
// Fill="{StaticResource vb_1}"
ImageFill img = (ImageFill)fs;
if (img.IsTiled || silverlight)
{
isTiledBitmap = true;// this causes bitmap to be written inline
}
else
{
string brushName = imageBrushes[img.ImagePath];
xw.WriteStartAttribute("Fill");
xw.WriteValue("{StaticResource " + brushName + "}");
xw.WriteEndAttribute();
}
}
}
if (ss != null)
{
if (ss is SolidStroke)
{
// StrokeThickness="3" StrokeLineJoin="Round" Stroke="#FF014393"
// StrokeStartLineCap="Round"
// StrokeEndLineCap="Round"
SolidStroke st = (SolidStroke)ss;
xw.WriteStartAttribute("StrokeThickness");
xw.WriteFloat(st.LineWidth);
xw.WriteEndAttribute();
xw.WriteStartAttribute("StrokeLineJoin");
xw.WriteString("Round");
xw.WriteEndAttribute();
xw.WriteStartAttribute("StrokeStartLineCap");
xw.WriteString("Round");
xw.WriteEndAttribute();
xw.WriteStartAttribute("StrokeEndLineCap");
xw.WriteString("Round");
xw.WriteEndAttribute();
xw.WriteStartAttribute("Stroke");
xw.WriteColor(st.Color);
xw.WriteEndAttribute();
}
}
float minX = float.PositiveInfinity;
float minY = float.PositiveInfinity;
float maxX = float.NegativeInfinity;
float maxY = float.NegativeInfinity;
xw.WriteStartAttribute("Data");
xw.WriteMoveTo(sh[0].StartPoint);
Point lastPoint = sh[0].StartPoint;
for (int i = 0; i < sh.Count; i++)
{
IShapeData sd = sh[i];
if (lastPoint != sd.StartPoint)
{
xw.WriteMoveTo(sd.StartPoint);
}
switch (sd.SegmentType)
{
case SegmentType.Line:
xw.WriteLineTo(sd.EndPoint);
lastPoint = sd.EndPoint;
break;
case SegmentType.CubicBezier:
CubicBezier cb = (CubicBezier)sd;
xw.WriteCubicCurveTo(cb.Control0, cb.Control1, cb.Anchor1);
lastPoint = cb.EndPoint;
minX = Math.Min(minX, cb.Control0.X);
maxX = Math.Max(maxX, cb.Control0.X);
minY = Math.Min(minY, cb.Control0.Y);
maxY = Math.Max(maxY, cb.Control0.Y);
minX = Math.Min(minX, cb.Control1.X);
maxX = Math.Max(maxX, cb.Control1.X);
minY = Math.Min(minY, cb.Control1.Y);
maxY = Math.Max(maxY, cb.Control1.Y);
break;
case SegmentType.QuadraticBezier:
QuadBezier qb = (QuadBezier)sd;
xw.WriteQuadraticCurveTo(qb.Control, qb.Anchor1);
lastPoint = qb.EndPoint;
minX = Math.Min(minX, qb.Control.X);
maxX = Math.Max(maxX, qb.Control.X);
minY = Math.Min(minY, qb.Control.Y);
maxY = Math.Max(maxY, qb.Control.Y);
break;
}
// need bounds for gradient :(
if (isGradient)
{
minX = Math.Min(minX, sd.StartPoint.X);
maxX = Math.Max(maxX, sd.StartPoint.X);
minY = Math.Min(minY, sd.StartPoint.Y);
maxY = Math.Max(maxY, sd.StartPoint.Y);
minX = Math.Min(minX, sd.EndPoint.X);
maxX = Math.Max(maxX, sd.EndPoint.X);
minY = Math.Min(minY, sd.EndPoint.Y);
maxY = Math.Max(maxY, sd.EndPoint.Y);
}
}
xw.WriteEndAttribute();
if (isGradient)
{
GradientFill gf = (GradientFill)fs;
// need a gradient def here
if (fs.FillType == FillType.Linear)
{
//<Path.Fill>
// <LinearGradientBrush StartPoint="0.14706,0.532137" EndPoint="1.14962,0.55353">
// <LinearGradientBrush.GradientStops>
// <GradientStop Color="#FF4A4A4A" Offset="0"/>
// <GradientStop Color="#FFB0B0B0" Offset="0.412067"/>
// <GradientStop Color="#FFBBBBBB" Offset="0.638141"/>
// <GradientStop Color="#FF545454" Offset="1"/>
// </LinearGradientBrush.GradientStops>
// </LinearGradientBrush>
//</Path.Fill>
xw.WriteStartElement("Path.Fill");
xw.WriteStartElement("LinearGradientBrush");
Matrix m = gf.Transform;
Rectangle r = GradientFill.GradientVexRect;
sysDraw2D.Matrix m2 = new sysDraw2D.Matrix(m.ScaleX, m.Rotate0, m.Rotate1, m.ScaleY, m.TranslateX, m.TranslateY);
float midY = r.Point.Y + (r.Size.Height / 2);
sysDraw.PointF pt0 = new sysDraw.PointF(r.Point.X, midY);
sysDraw.PointF pt1 = new sysDraw.PointF(r.Point.X + r.Size.Width, midY);
sysDraw.PointF[] pts = new sysDraw.PointF[] { pt0, pt1 };
m2.TransformPoints(pts);
float ratX = 1 / (maxX - minX);
float ratY = 1 / (maxY - minY);
float d0x = (pts[0].X - minX) * ratX;
float d0y = (pts[0].Y - minY) * ratY;
float d1x = (pts[1].X - minX) * ratX;
float d1y = (pts[1].Y - minY) * ratY;
xw.WriteStartAttribute("StartPoint");
xw.WritePoint(new Point(d0x, d0y));
xw.WriteEndAttribute();
xw.WriteStartAttribute("EndPoint");
xw.WritePoint(new Point(d1x, d1y));
xw.WriteEndAttribute();
xw.WriteStartAttribute("SpreadMethod");
xw.WriteValue("Pad");
xw.WriteEndAttribute();
xw.WriteStartElement("LinearGradientBrush.GradientStops");
for (int i = 0; i < gf.Stops.Count; i++)
{
xw.WriteStartElement("GradientStop");
xw.WriteStartAttribute("Color");
xw.WriteColor(gf.Fills[i]);
xw.WriteEndAttribute();
xw.WriteStartAttribute("Offset");
xw.WriteFloat(gf.Stops[i]);
xw.WriteEndAttribute();
xw.WriteEndElement(); // GradientStop
}
xw.WriteEndElement(); // LinearGradientBrush.GradientStops
xw.WriteEndElement(); // LinearGradientBrush
xw.WriteEndElement(); // Path.Fill
}
else if (fs.FillType == FillType.Radial)
{
//<Ellipse.Fill>
// <RadialGradientBrush RadiusX="0.622359" RadiusY="0.604589" Center="0.5,0.5" GradientOrigin="0.5,0.5">
// <RadialGradientBrush.RelativeTransform>
// <TransformGroup/>
// </RadialGradientBrush.RelativeTransform>
// <GradientStop Color="#95000000" Offset="0.347222"/>
// <GradientStop Color="#007877A7" Offset="0.773148"/>
// </RadialGradientBrush>
//</Ellipse.Fill>
xw.WriteStartElement("Path.Fill");
xw.WriteStartElement("RadialGradientBrush");
Matrix m = gf.Transform;
Rectangle r = GradientFill.GradientVexRect;
sysDraw2D.Matrix m2 = new sysDraw2D.Matrix(m.ScaleX, m.Rotate0, m.Rotate1, m.ScaleY, m.TranslateX, m.TranslateY);
float midX = r.Point.X + (r.Size.Width / 2);
float midY = r.Point.Y + (r.Size.Height / 2);
sysDraw.PointF pt0 = new sysDraw.PointF(midX, midY); // center
sysDraw.PointF pt1 = new sysDraw.PointF(r.Point.X + r.Size.Width, midY); // radius vector
sysDraw.PointF[] pts = new sysDraw.PointF[] { pt0, pt1 };
m2.TransformPoints(pts);
float ratX = 1 / (maxX - minX);
float ratY = 1 / (maxY - minY);
float d0x = (pts[0].X - minX) * ratX;
float d0y = (pts[0].Y - minY) * ratY;
float d1x = (pts[1].X - pts[0].X);
//float d1y = (pts[1].Y - pts[0].Y) * ratY;
float rad = (float)Math.Sqrt(d1x * d1x);
xw.WriteStartAttribute("RadiusX");
xw.WriteFloat(rad * ratX);
xw.WriteEndAttribute();
xw.WriteStartAttribute("RadiusY");
xw.WriteFloat(rad * ratY);
xw.WriteEndAttribute();
xw.WriteStartAttribute("Center");
xw.WritePoint(new Point(d0x, d0y));
xw.WriteEndAttribute();
xw.WriteStartAttribute("GradientOrigin");
xw.WritePoint(new Point(d0x, d0y));
xw.WriteEndAttribute();
xw.WriteStartAttribute("SpreadMethod");
xw.WriteValue("Pad");
xw.WriteEndAttribute();
//xw.WriteStartElement("RadialGradientBrush.GradientStops");
for (int i = 0; i < gf.Stops.Count; i++)
{
xw.WriteStartElement("GradientStop");
xw.WriteStartAttribute("Color");
xw.WriteColor(gf.Fills[i]);
xw.WriteEndAttribute();
xw.WriteStartAttribute("Offset");
xw.WriteFloat(1 - gf.Stops[i]); // xaml fill is reversed from gdi
xw.WriteEndAttribute();
xw.WriteEndElement(); // GradientStop
}
//xw.WriteEndElement(); // LinearGradientBrush.GradientStops
xw.WriteEndElement(); // LinearGradientBrush
xw.WriteEndElement(); // Path.Fill
}
}
else if (isTiledBitmap)
{
//<Path.Fill>
// <ImageBrush ImageSource="Resources\bmp_1.jpg" TileMode="Tile" RelativeTransform=".2,0,0,.2,0,0"/>
//</Path.Fill>
ImageFill img = (ImageFill)fs;
xw.WriteStartElement("Path.Fill");
xw.WriteStartElement("ImageBrush");
xw.WriteStartAttribute("ImageSource");
xw.WriteValue(img.ImagePath);
xw.WriteEndAttribute();
if (!silverlight)
{
xw.WriteStartAttribute("TileMode");
xw.WriteValue("Tile");
xw.WriteEndAttribute();
}
//xw.WriteStartAttribute("ViewportUnits");
//xw.WriteValue("Absolute");
//xw.WriteEndAttribute();
Matrix pMatrix = ApplyMatrixToShape(sh, img.Matrix, images[img.ImagePath].StrokeBounds);
//Matrix pMatrix = ApplyMatrixToImage(img.Matrix, images[img.ImagePath].Bounds);
xw.WriteStartAttribute("RelativeTransform");
xw.WriteMatrix(pMatrix);
//xw.WriteMatrix(img.Matrix);
xw.WriteEndAttribute();
xw.WriteEndElement(); // Path.Fill
xw.WriteEndElement(); // ImageBrush
}
xw.WriteEndElement(); // Path
}
public ImageWidget(string imageId, ImageFill imageFill)
: base()
{
ImageId = imageId;
ImageFill = imageFill;
}
protected override void RenderPath(FillStyle fs, StrokeStyle ss, List <IShapeData> sh, bool silverlight)
{
// <Path Fill="#FFFF0000"
// StrokeThickness="0.00491913" StrokeLineJoin="Round" Stroke="#FF014393"
// Data="M 196.667,4L 388.667,100L 388.667,292L 196.667,388L 4.66669,292L 4.66669,100L 196.667,4 Z "/>
if (sh.Count == 0)
{
return;
}
xw.WriteStartElement("path");
if (fs != null)
{
switch (fs.FillType)
{
case FillType.Solid:
Color c = ((SolidFill)fs).Color;
xw.WriteStartAttribute("fill");
xw.WriteColor(c);
xw.WriteEndAttribute();
// try to clean up faint edges
if (ss == null && c != new Color(0xFF, 0xFF, 0xFF) && c.A != 0)
{
ss = new SolidStroke(0.3F, c);
}
break;
case FillType.Linear:
case FillType.Radial:
case FillType.Focal:
GradientFill gf = (GradientFill)fs;
// fill="url(#lg)"
xw.WriteStartAttribute("fill");
xw.WriteValue("url(#gf_" + gf.TagId + ")");
xw.WriteEndAttribute();
break;
case FillType.Image:
ImageFill img = (ImageFill)fs;
if (img.IsTiled)
{
//isTiledBitmap = true;
}
break;
}
}
else
{
xw.WriteStartAttribute("fill");
xw.WriteValue("none");
xw.WriteEndAttribute();
}
if (ss != null)
{
if (ss is SolidStroke)
{
// StrokeThickness="3" StrokeLineJoin="Round" Stroke="#FF014393"
// StrokeStartLineCap="Round"
// StrokeEndLineCap="Round"
SolidStroke st = (SolidStroke)ss;
if (st.LineWidth != 0.3f)
{
xw.WriteStartAttribute("stroke-width");
xw.WriteFloat(st.LineWidth);
xw.WriteEndAttribute();
}
xw.WriteStartAttribute("stroke");
xw.WriteColor(st.Color);
xw.WriteEndAttribute();
}
}
// todo: this is pre defined in svg
//if (isTiledBitmap)
//{
// //<Path.Fill>
// // <ImageBrush ImageSource="Resources\bmp_1.jpg" TileMode="Tile" RelativeTransform=".2,0,0,.2,0,0"/>
// //</Path.Fill>
// ImageFill img = (ImageFill)fs;
// xw.WriteStartElement("Path.Fill");
// xw.WriteStartElement("ImageBrush");
// xw.WriteStartAttribute("ImageSource");
// xw.WriteValue(img.ImagePath);
// xw.WriteEndAttribute();
// if (!silverlight)
// {
// xw.WriteStartAttribute("TileMode");
// xw.WriteValue("Tile");
// xw.WriteEndAttribute();
// }
// Matrix pMatrix = ApplyMatrixToShape(sh, img.Matrix, images[img.ImagePath].StrokeBounds);
// //Matrix pMatrix = ApplyMatrixToImage(img.Matrix, images[img.ImagePath].Bounds);
// xw.WriteStartAttribute("RelativeTransform");
// xw.WriteMatrix(pMatrix);
// //xw.WriteMatrix(img.Matrix);
// xw.WriteEndAttribute();
// xw.WriteEndElement(); // Path.Fill
// xw.WriteEndElement(); // ImageBrush
//}
xw.WriteStartAttribute("d");
xw.WriteMoveTo(sh[0].StartPoint);
Point lastPoint = sh[0].StartPoint;
for (int i = 0; i < sh.Count; i++)
{
IShapeData sd = sh[i];
if (lastPoint != sd.StartPoint)
{
xw.WriteMoveTo(sd.StartPoint);
}
switch (sd.SegmentType)
{
case SegmentType.Line:
xw.WriteLineTo(sd.EndPoint);
lastPoint = sd.EndPoint;
break;
case SegmentType.CubicBezier:
CubicBezier cb = (CubicBezier)sd;
xw.WriteCubicCurveTo(cb.Control0, cb.Control1, cb.Anchor1);
lastPoint = cb.EndPoint;
break;
case SegmentType.QuadraticBezier:
QuadBezier qb = (QuadBezier)sd;
xw.WriteQuadraticCurveTo(qb.Control, qb.Anchor1);
lastPoint = qb.EndPoint;
break;
}
}
xw.WriteEndAttribute();
xw.WriteEndElement(); // Path
}
