private void BuildTextures(OptFile opt)
{
this.nullTexture = null;
this.textures = null;
if (opt == null)
{
return;
}
this.nullTexture = new DiffuseMaterial(Brushes.White);
this.textures = new Dictionary <string, Material>();
foreach (var texture in opt.Textures.Values)
{
var image = CreateTexture(opt, texture.Name);
image.Freeze();
var brush = new ImageBrush(image)
{
ViewportUnits = BrushMappingMode.Absolute,
Stretch = Stretch.Fill,
TileMode = TileMode.Tile,
Opacity = texture.HasAlpha ? 0.999 : 1.0
};
brush.Freeze();
var material = new DiffuseMaterial(brush);
material.Freeze();
this.textures.Add(texture.Name, material);
}
}
static ShinyImageControl()
{
VerticalAlignmentProperty.OverrideMetadata(typeof(ShinyImageControl), new FrameworkPropertyMetadata(VerticalAlignment.Stretch));
HorizontalAlignmentProperty.OverrideMetadata(typeof(ShinyImageControl), new FrameworkPropertyMetadata(HorizontalAlignment.Stretch));
RenderOptions.BitmapScalingModeProperty.OverrideMetadata(typeof(ShinyImageControl), new FrameworkPropertyMetadata(BitmapScalingMode.Linear));
_glareBrush = new LinearGradientBrush()
{
StartPoint = new Point(0.5, 0.4),
EndPoint = new Point(0.65, 0.85),
GradientStops =
{
new GradientStop(Color.FromArgb(51, 255, 255, 255), 0.0),
new GradientStop(Color.FromArgb(51, 255, 255, 255), 0.6),
new GradientStop(Color.FromArgb(0, 0, 0, 0), 0.6),
},
};
var bi = new BitmapImage();
bi.BeginInit();
bi.CacheOption = BitmapCacheOption.OnLoad;
bi.DecodePixelWidth = 100;
bi.UriSource = new Uri(@"pack://application:,,,/Resources/Images/avatar_background.png");
bi.EndInit();
_avatarBrush = new ImageBrush(bi);
_avatarBrush.Freeze();
}
static Airplane()
{
try
{
Assembly assembly = Assembly.GetExecutingAssembly();
string[] names = assembly.GetManifestResourceNames();
string name = names.FirstOrDefault(x => x.Contains("WFTools3D.jpg"));
if (name != null)
{
Stream stream = assembly.GetManifestResourceStream(name);
if (stream != null)
{
BitmapImage bitmap = new BitmapImage();
bitmap.BeginInit();
bitmap.StreamSource = stream;
bitmap.EndInit();
ImageBrush imbrush = new ImageBrush(bitmap);
imbrush.TileMode = TileMode.Tile;
imbrush.Viewport = new Rect(0, 0, 0.5, 1);
imbrush.Freeze();
brush = imbrush;
}
}
}
catch
{
brush = Brushes.Silver;
}
}
static HatchBrushes()
{
byte[] pixels = new byte[8];
for (int i = 0; i < pixels.Length; i++)
{
pixels[i] = ((i & 1) == 0) ? (byte)0xAA : (byte)0x55;
}
// Try creating a new image with a custom palette.
List <Color> colors = new List <Color> {
Colors.Black, Colors.White
};
BitmapPalette myPalette = new BitmapPalette(colors);
BitmapSource source = BitmapSource.Create(8, 8, 96, 96, PixelFormats.Indexed1, myPalette, pixels, 1);
ImageBrush brush = new ImageBrush(source)
{
TileMode = TileMode.Tile,
ViewportUnits = BrushMappingMode.Absolute,
Viewport = new Rect(0, 0, 8, 8),
ViewboxUnits = BrushMappingMode.Absolute,
Viewbox = new Rect(0, 0, 8, 8)
};
brush.Freeze();
hatchBrush = brush;
}
/// <summary>
/// Creates the alpha mask with the tiled image.
/// </summary>
/// <returns>The brush to use for masking.</returns>
private static ImageBrush CreateTileImageMask()
{
ImageSource tileImage = LookAndFeel.TileImage;
var drawings = new DrawingGroup();
// TODO: Get from image.
var imageWidth = 172;
var imageHeight = 100;
for (var x = 0; x < (maxScreenWidth / imageWidth) + 1; x++)
{
for (var y = 0; y < (maxScreenHeight / imageHeight) + 1; y++)
{
var drawing = new ImageDrawing();
drawing.Rect = new Rect(x * imageWidth, y * imageHeight, imageWidth, imageHeight);
drawing.ImageSource = tileImage;
drawing.Freeze();
drawings.Children.Add(drawing);
}
}
drawings.Freeze();
var mask = new DrawingImage(drawings);
mask.Freeze();
var maskBrush = new ImageBrush(mask);
maskBrush.Freeze();
return(maskBrush);
}
private static ReadOnlyCollection <DiffuseMaterial> GetSamplePictures()
{
IList <string> files = SampleImageHelper.GetPicturePaths().ToList();
if (files.Count > 0)
{
return(files
.Select(file =>
{
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.BeginInit();
bitmapImage.UriSource = new Uri(file);
bitmapImage.DecodePixelWidth = 320;
bitmapImage.DecodePixelHeight = 240;
bitmapImage.EndInit();
bitmapImage.Freeze();
ImageBrush imageBrush = new ImageBrush(bitmapImage);
imageBrush.Stretch = Stretch.UniformToFill;
imageBrush.ViewportUnits = BrushMappingMode.Absolute;
imageBrush.Freeze();
return new DiffuseMaterial(imageBrush);
})
.ToReadOnlyCollection());
}
else
{
return((new Brush[] { Brushes.LightBlue, Brushes.Pink, Brushes.LightGray, Brushes.Yellow, Brushes.Orange, Brushes.LightGreen })
.Select(brush => new DiffuseMaterial(brush))
.ToReadOnlyCollection());
}
}
/// <summary>
/// Updates the material when the texture changes.
/// </summary>
protected void TextureChanged()
{
var w = 256;
var h = 256;
var bitmap = new RenderTargetBitmap(opacityLevels * w, h, 96, 96, PixelFormats.Pbgra32);
for (int i = 0; i < opacityLevels; i++)
{
var rect = new Rectangle {
Opacity = 1 - ((double)i / opacityLevels), Fill = this.Texture, Width = w, Height = h
};
rect.Arrange(new Rect(w * i, 0, w, h));
bitmap.Render(rect);
}
var brush = new ImageBrush(bitmap)
{
ViewportUnits = BrushMappingMode.Absolute
};
brush.Freeze();
var material = new DiffuseMaterial(brush)
{
AmbientColor = Colors.White
};
material.Freeze();
this.model.Material = material;
}
protected override void OnDraw(DrawingContext drawingContext,
StylusPointCollection stylusPoints,
Geometry geometry,
Brush fillBrush)
{
// <Snippet17>
if (imageBrush == null)
{
// Create an ImageBrush. imageFile is a string that's a path to an image file.
image1 = new BitmapImage(new Uri(imageFile));
imageBrush = new ImageBrush(image1);
// Don't tile, don't stretch; align to top/left.
imageBrush.TileMode = TileMode.None;
imageBrush.Stretch = Stretch.None;
imageBrush.AlignmentX = AlignmentX.Left;
imageBrush.AlignmentY = AlignmentY.Top;
// Map the brush to the entire bounds of the element.
imageBrush.ViewportUnits = BrushMappingMode.Absolute;
imageBrush.Viewport = this.ElementBounds;
imageBrush.Freeze();
}
// </Snippet17>
drawingContext.DrawGeometry(imageBrush, null, geometry);
}
private static void LoadTextures()
{
var uris = new List <Uri>
{
new Uri("pack://application:,,,/Resources/PrimitiveMeshView/TestTexture.png"),
new Uri("pack://application:,,,/Resources/PrimitiveMeshView/TestTexture.png"),
new Uri("pack://application:,,,/Resources/PrimitiveMeshView/TestTexture.png"),
};
m_textures.Clear();
foreach (var uri in uris)
{
var resource = Application.GetResourceStream(uri);
using var reader = new BinaryReader(resource.Stream);
var data = reader.ReadBytes((int)resource.Stream.Length);
var imageSource = (BitmapSource) new ImageSourceConverter().ConvertFrom(data);
imageSource.Freeze();
var brush = new ImageBrush(imageSource);
brush.Transform = new ScaleTransform(1, -1, 0.5, 0.5);
brush.ViewportUnits = BrushMappingMode.Absolute;
brush.Freeze();
m_textures.Add(brush);
}
}
public StretchModes()
{
// Create an ImageBrush with its Stretch
// property set to Uniform. The image it
// contains will be expanded as much as possible
// to fill the output area while still
// preserving its aspect ratio.
ImageBrush uniformBrush = new ImageBrush();
uniformBrush.ImageSource =
new BitmapImage(new Uri("sampleImages\\square.jpg", UriKind.Relative));
uniformBrush.Stretch = Stretch.Uniform;
// Freeze the brush (make it unmodifiable) for performance benefits.
uniformBrush.Freeze();
// Create a rectangle and paint it with the ImageBrush.
Rectangle rectangle1 = new Rectangle();
rectangle1.Width = 300;
rectangle1.Height = 150;
rectangle1.Stroke = Brushes.MediumBlue;
rectangle1.StrokeThickness = 1.0;
rectangle1.Fill = uniformBrush;
// Create an ImageBrush with its Stretch
// property set to UniformToFill. The image it
// contains will be expanded to completely fill
// the rectangle, but its aspect ratio is preserved.
ImageBrush uniformToFillBrush = new ImageBrush();
uniformToFillBrush.ImageSource =
new BitmapImage(new Uri("sampleImages\\square.jpg", UriKind.Relative));
uniformToFillBrush.Stretch = Stretch.UniformToFill;
// Freeze the brush (make it unmodifiable) for performance benefits.
uniformToFillBrush.Freeze();
// Create a rectangle and paint it with the ImageBrush.
Rectangle rectangle2 = new Rectangle();
rectangle2.Width = 300;
rectangle2.Height = 150;
rectangle2.Stroke = Brushes.MediumBlue;
rectangle2.StrokeThickness = 1.0;
rectangle2.Margin = new Thickness(0, 10, 0, 0);
rectangle2.Fill = uniformToFillBrush;
StackPanel mainPanel = new StackPanel();
mainPanel.Children.Add(rectangle1);
mainPanel.Children.Add(rectangle2);
Content = mainPanel;
Background = Brushes.White;
Margin = new Thickness(20);
Title = "ImageBrush Stretch Modes";
}
/// <summary>
/// Crea un dashboard en un canvas a partir de una lista de pictogramas
/// </summary>
/// <param name="imageItems">Lista de pictogramas a incluir en el dashboard</param>
/// <param name="canvas">Canvas en el que dibujar los pictogramas</param>
public void CreateDashboard(List <Model.ImageItem> imageItems, Canvas canvas)
{
Canvas myCanvas = canvas;
canvas.Opacity = 0;
int numColumns = 5;
int numRows;
if (imageItems.Count < 16)
{
numRows = 3;
}
else
{
numRows = 5;
}
double left;
double top;
left = 0;
top = 0;
for (int i = 0; i < imageItems.Count; i++)
{
string img = imageItems[i].Image;
Rectangle rectangle = new Rectangle
{
Stretch = Stretch.Uniform,
Width = myCanvas.ActualWidth / numColumns,
Height = myCanvas.ActualHeight / numRows
};
ImageBrush brush = new ImageBrush
{
ImageSource = new BitmapImage(new Uri(img, UriKind.Absolute))
};
brush.Stretch = Stretch.Uniform;
brush.Freeze();
rectangle.Fill = brush;
if (left + rectangle.Width > myCanvas.ActualWidth)
{
left = 0;
top += rectangle.Height;
}
Canvas.SetLeft(rectangle, left);
Canvas.SetTop(rectangle, top);
myCanvas.Children.Add(rectangle);
left += rectangle.Width;
dataAccess.MoveImageFromTempToDestination(imageItems[i].Title);
}
canvas.Opacity = 1;
}
ImageBrush GetBrush(string name, bool doFreeze = true)
{
ImageBrush brush = Resources[name] as ImageBrush;
if (doFreeze)
{
brush.Freeze();
}
return(brush);
}
static public ImageBrush ConvertToImageBrush(System.Drawing.Bitmap img)
{
var bitmap = new System.Drawing.Bitmap(img);
var bitmapSource = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(bitmap.GetHbitmap(), IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
bitmap.Dispose();
ImageBrush result = new ImageBrush(bitmapSource);
result.Freeze();
return(result);
}
private Brush GetVisualBrush(Visual visual)
{
Contract.Requires(visual != null, "Visual is null");
var target = new RenderTargetBitmap((int)this.ActualWidth, (int)this.ActualHeight, 96, 96, PixelFormats.Pbgra32);
target.Render(visual);
var brush = new ImageBrush(target);
brush.Freeze();
return(brush);
}
private void LoadSongInfo(List <SongItemControl> items)
{
foreach (SongItemControl item in items)
{
String time = GetDuration(item.Path);
String SongName;
String Author = "UNKNOW";
using (TagLib.File fileTags = TagLib.File.Create(item.Path))
{
SongName = fileTags.Tag.Title;
if (fileTags.Tag.Performers.Count() > 0)
{
Author = fileTags.Tag.Performers[0];
}
}
using (ShellFile shellFile = ShellFile.FromFilePath(item.Path))
{
using (Bitmap shellThumb = shellFile.Thumbnail.ExtraLargeBitmap)
{
IntPtr hBitMap = shellThumb.GetHbitmap();
try
{
var bs = Imaging.CreateBitmapSourceFromHBitmap(hBitMap, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
bs.Freeze();
var image = new ImageBrush(bs);
image.Freeze();
item.Dispatcher.Invoke(() =>
{
item.Icon = image;
item.Time = time;
if (!String.IsNullOrWhiteSpace(SongName))
{
item.ItemName = SongName;
}
item.Author = Author;
});
}
finally
{
DeleteObject(hBitMap); // prevent memory leak from Imaging.CreateBitmapSourceFromHBitmap
}
}
}
}
items.Clear();
// force garbage collect
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true);
}
public override RBrush GetTextureBrush(RImage image, RRect dstRect, RPoint translateTransformLocation)
{
var brush = new ImageBrush(((ImageAdapter)image).Image);
brush.Stretch = Stretch.None;
brush.TileMode = TileMode.Tile;
brush.Viewport = Utils.Convert(dstRect);
brush.ViewportUnits = BrushMappingMode.Absolute;
brush.Transform = new TranslateTransform(translateTransformLocation.X, translateTransformLocation.Y);
brush.Freeze();
return(new BrushAdapter(brush));
}
public void InitializeFromVectorGraphics(VisualBrush visualBrush, double width, double height) //, Boolean grey)
{
RenderTargetBitmap renderTargetImage = CreateFromVectorGraphics(visualBrush, width, height);
CachedFormatConvertedBitmap = new FormatConvertedBitmap(renderTargetImage, PixelFormats.Gray32Float, null, 0);
CachedFormatConvertedBitmap.Freeze();
CachedOpacityMask = new ImageBrush(renderTargetImage);
CachedOpacityMask.Opacity = 0.4;
CachedOpacityMask.Freeze();
SetGrey(!IsEnabled);
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
// If user changes dpi/virtual screen height during applicaiton lifetime,
// wpf will scale the image up for us.
var width = 20;
var height = (int)SystemParameters.VirtualScreenHeight;
var dpix = (int)dpiX_.GetValue(null);
var dpiy = (int)dpiY_.GetValue(null);
var stride = 4 * ((width * PixelFormats.Bgr24.BitsPerPixel + 31) / 32);
// dithering parameters
var bayerMatrixCoefficient = 1.0 / (bayerMatrix_.Length + 1);
var bayerMatrixSize = bayerMatrix_.GetLength(0);
// Create pixel data of image
var buffer = new byte[height * stride];
for (var line = 0; line < height; line++)
{
var scale = (double)line / height;
for (var x = 0; x < width * 3; x += 3)
{
// scaling of color
var blue = this.To.B * scale + this.From.B * (1.0 - scale);
var green = this.To.G * scale + this.From.G * (1.0 - scale);
var red = this.To.R * scale + this.From.R * (1.0 - scale);
// ordered dithering of color
// source: http://en.wikipedia.org/wiki/Ordered_dithering
buffer[x + line * stride] =
(byte)(blue + bayerMatrixCoefficient
* bayerMatrix_[x % bayerMatrixSize, line % bayerMatrixSize]);
buffer[x + line * stride + 1] =
(byte)(green + bayerMatrixCoefficient
* bayerMatrix_[x % bayerMatrixSize, line % bayerMatrixSize]);
buffer[x + line * stride + 2] =
(byte)(red + bayerMatrixCoefficient
* bayerMatrix_[x % bayerMatrixSize, line % bayerMatrixSize]);
}
}
var image = BitmapSource.Create(width, height, dpix, dpiy, PixelFormats.Bgr24, null, buffer, stride);
image.Freeze();
var brush = new ImageBrush(image);
brush.Freeze();
return(brush);
}
private static IList <DiffuseMaterial> GetSamplePictures()
{
IList <DiffuseMaterial> materials;
IList <string> files = Helpers.GetPicturePaths();
if (files.Count > 0)
{
materials = new List <DiffuseMaterial>();
foreach (string file in files)
{
Uri uri = new Uri(file);
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.BeginInit();
bitmapImage.UriSource = uri;
bitmapImage.DecodePixelWidth = 320;
bitmapImage.DecodePixelHeight = 240;
bitmapImage.EndInit();
bitmapImage.Freeze();
ImageBrush imageBrush = new ImageBrush(bitmapImage);
imageBrush.Stretch = Stretch.UniformToFill;
imageBrush.ViewportUnits = BrushMappingMode.Absolute;
imageBrush.Freeze();
DiffuseMaterial diffuseMaterial = new DiffuseMaterial(imageBrush);
materials.Add(diffuseMaterial);
}
}
else
{
Brush[] brushes = new Brush[] {
Brushes.LightBlue,
Brushes.Pink,
Brushes.LightGray,
Brushes.Yellow,
Brushes.Orange,
Brushes.LightGreen
};
DiffuseMaterial[] materialsArray =
brushes.Select(brush => new DiffuseMaterial(brush)).ToArray();
materials = materialsArray;
}
return(materials);
}
private IEnumerable <Material> GetMaterials(IGeometryModel model)
{
var indexes = model.Meshes.SelectMany(m => m.Submeshes)
.Select(s => s.MaterialIndex).Distinct().ToArray();
var bitmapLookup = new Dictionary <int, DiffuseMaterial>();
for (short i = 0; i < model.Materials.Count; i++)
{
if (!indexes.Contains(i))
{
yield return(null);
continue;
}
var mat = model.Materials[i];
DiffuseMaterial material;
try
{
var diffuse = mat.Submaterials.First(m => m.Usage == MaterialUsage.Diffuse);
if (!bitmapLookup.ContainsKey(diffuse.Bitmap.Id))
{
var dds = diffuse.Bitmap.ToDds(0);
var brush = new ImageBrush(dds.ToBitmapSource(new DdsOutputArgs(DecompressOptions.Bgr24)))
{
ViewportUnits = BrushMappingMode.Absolute,
TileMode = TileMode.Tile,
Viewport = new Rect(0, 0, 1f / Math.Abs(diffuse.Tiling.X), 1f / Math.Abs(diffuse.Tiling.Y))
};
brush.Freeze();
material = new DiffuseMaterial(brush);
material.Freeze();
bitmapLookup[diffuse.Bitmap.Id] = material;
}
else
{
material = bitmapLookup[diffuse.Bitmap.Id];
}
}
catch
{
material = ErrorMaterial;
}
yield return(material);
}
}
void LoadAvatar(string rpUri, WeakReference <ImageBrush> rpWeakReference)
{
var rImage = BitmapFrame.Create(new Uri(rpUri), BitmapCreateOptions.IgnoreImageCache, BitmapCacheOption.OnLoad);
rImage.Freeze();
var rBrush = new ImageBrush(rImage);
rBrush.Freeze();
rpWeakReference.SetTarget(rBrush);
Brush = rBrush;
}
private static Brush CreateBrushFromVisual(Visual v, int width, int height)
{
if (v == null)
{
throw new ArgumentNullException(nameof(v));
}
var target = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Pbgra32);
target.Render(v);
var brush = new ImageBrush(target);
brush.Freeze();
return(brush);
}
public Brush GetBrush(int width, int height)
{
//If user changes dpi/virtual screen height during applicaiton lifetime,
//wpf will scale the image up for us.
int dpix = (int)_dpiX.GetValue(null);
int dpiy = (int)_dpiY.GetValue(null);
int stride = 4 * ((width * PixelFormats.Bgra32.BitsPerPixel + 31) / 32);
//dithering parameters
double bayerMatrixCoefficient = 1.0 / (_bayerMatrix.Length + 1);
int bayerMatrixSize = _bayerMatrix.GetLength(0);
//Create pixel data of image
byte[] buffer = new byte[height * stride];
for (int line = 0; line < height; line++)
{
for (int x = 0; x < width * 4; x += 4)
{
double scale = Math.Sqrt(
Math.Pow((double)line / height, 2)
*
Math.Pow((double)x / (width * 4), 2)
);
//scale = Math.Pow(scale,1/2.2);
//scaling of color
double blue = ((To.B * scale) + (From.B * (1.0 - scale)));
double green = ((To.G * scale) + (From.G * (1.0 - scale)));
double red = ((To.R * scale) + (From.R * (1.0 - scale)));
double alpha = ((To.A * scale) + (From.A * (1.0 - scale)));
//ordered dithering of color
//source: http://en.wikipedia.org/wiki/Ordered_dithering
buffer[x + line * stride] = (byte)(blue + bayerMatrixCoefficient * _bayerMatrix[x % bayerMatrixSize, line % bayerMatrixSize]);
buffer[x + line * stride + 1] = (byte)(green + bayerMatrixCoefficient * _bayerMatrix[x % bayerMatrixSize, line % bayerMatrixSize]);
buffer[x + line * stride + 2] = (byte)(red + bayerMatrixCoefficient * _bayerMatrix[x % bayerMatrixSize, line % bayerMatrixSize]);
buffer[x + line * stride + 3] = (byte)(alpha + bayerMatrixCoefficient * _bayerMatrix[x % bayerMatrixSize, line % bayerMatrixSize]);
}
}
var image = BitmapSource.Create(width, height, dpix, dpiy, PixelFormats.Bgra32, null, buffer, stride);
image.Freeze();
var brush = new ImageBrush(image);
brush.Freeze();
return(brush);
}
Brush MakeBrushFromVisual(Visual visual, Rect bounds)
{
var viewport = visual as Viewport3D;
if (viewport == null)
{
Drawing drawing = VisualTreeHelper.GetDrawing(visual);
if (drawOutlines)
{
bounds.Inflate(OutlinePen.Thickness / 2, OutlinePen.Thickness / 2);
}
var offsetMatrix = new Matrix(1, 0, 0, 1, -bounds.Left, -bounds.Top);
var offsetMatrixTransform = new MatrixTransform(offsetMatrix);
offsetMatrixTransform.Freeze();
var drawingVisual = new DrawingVisual();
var drawingContext = drawingVisual.RenderOpen();
drawingContext.PushTransform(offsetMatrixTransform);
if (drawOutlines)
{
drawingContext.DrawRectangle(null, OutlinePen, bounds);
}
drawingContext.DrawDrawing(drawing);
drawingContext.Pop();
drawingContext.Close();
visual = drawingVisual;
}
var renderTargetBitmap = new RenderTargetBitmap((int)Math.Ceiling(bounds.Width),
(int)Math.Ceiling(bounds.Height), 96, 96, PixelFormats.Default);
if (viewport != null)
{
typeof(RenderTargetBitmap).GetMethod("RenderForBitmapEffect",
BindingFlags.Instance | BindingFlags.NonPublic).Invoke(renderTargetBitmap,
new object[] { visual, Matrix.Identity, Rect.Empty });
}
else
{
renderTargetBitmap.Render(visual);
}
renderTargetBitmap.Freeze();
var imageBrush = new ImageBrush(renderTargetBitmap);
imageBrush.Freeze();
return(imageBrush);
}
/// <summary>
/// Creates a brush based on the current appearnace of a visual element. The brush is an ImageBrush and once created, won't update its look
/// </summary>
/// <param name="v">The visual element to take a snapshot of</param>
private Brush CreateBrushFromVisual(Visual v)
{
if (v == null)
{
throw new ArgumentNullException("v");
}
var target = new RenderTargetBitmap((int)this.ActualWidth, (int)this.ActualHeight, 96, 96, PixelFormats.Pbgra32);
target.Render(v);
var brush = new ImageBrush(target);
brush.Freeze();
return(brush);
}
/// <summary>
/// Erzeugt einen gerenderten Brush aus einem Visual
/// </summary>
/// <param name="visual"></param>
/// <returns></returns>
public static Brush CreateBrushFromVisual(Visual visual, int width, int height)
{
if (visual == null)
{
throw new ArgumentNullException("visual");
}
RenderTargetBitmap target = new RenderTargetBitmap(Math.Max(width, 1), Math.Max(height, 1), 96, 96, PixelFormats.Pbgra32);
target.Render(visual);
ImageBrush brush = new ImageBrush(target);
brush.Freeze();
return(brush);
}
void OnShipChanged(int rpID)
{
if (rpID == 0)
{
Brush = null;
return;
}
var rIsModAvailable = File.Exists(r_ModRootDirectory + rpID + "_n.png");
if (!rIsModAvailable && !File.Exists(r_DefaultRootDirectory + rpID + "_n.png"))
{
Brush = null;
return;
}
WeakReference <ImageBrush> rBrushWeakReference;
if (!r_CachedAvatars.TryGetValue(rpID, out rBrushWeakReference))
{
r_CachedAvatars.Add(rpID, rBrushWeakReference = new WeakReference <ImageBrush>(null));
}
ImageBrush rBrush;
if (rBrushWeakReference.TryGetTarget(out rBrush))
{
Brush = rBrush;
return;
}
BitmapSource rImage;
if (!rIsModAvailable)
{
rImage = BitmapFrame.Create(new Uri("pack://siteoforigin:,,,/Resources/Avatars/Ships/" + rpID + "_n.png"));
}
else
{
rImage = BitmapFrame.Create(new Uri("pack://siteoforigin:,,,/Mods/ShipAvatars/" + rpID + "_n.png"));
}
rImage.Freeze();
rBrush = new ImageBrush(rImage);
rBrush.Freeze();
rBrushWeakReference.SetTarget(rBrush);
Brush = rBrush;
}
public async Task Refresh()
{
var fileName = default(string);
var outputStream = PlaybackManager.CurrentStream;
if (outputStream != null)
{
fileName = ArtworkProvider.Find(
outputStream.PlaylistItem,
ArtworkType.FrontCover
);
}
if (string.IsNullOrEmpty(fileName) || !File.Exists(fileName))
{
var source = ImageLoader.Load(
ThemeLoader.Theme.Id,
() => ThemeLoader.Theme.ArtworkPlaceholder,
true
);
var brush = new ImageBrush(source)
{
Stretch = Stretch.Uniform
};
brush.Freeze();
await Windows.Invoke(() =>
{
this.Background = brush;
this.IsComponentEnabled = false;
}).ConfigureAwait(false);
}
else
{
var source = ImageLoader.Load(
fileName,
fileName,
0,
0,
true
);
await Windows.Invoke(() =>
{
this.Background = new ImageBrush(source)
{
Stretch = Stretch.Uniform
};
this.IsComponentEnabled = true;
}).ConfigureAwait(false);
}
}
private Brush CreateBrushFromVisual(Visual iVisual)
{
if (iVisual == null)
{
throw new ArgumentNullException("iVisual");
}
dynamic target = new RenderTargetBitmap(Convert.ToInt32(this.ActualWidth), Convert.ToInt32(this.ActualHeight), 96, 96, PixelFormats.Pbgra32);
target.Render(iVisual);
dynamic brush = new ImageBrush(target);
brush.Freeze();
return(brush);
}
public static Brush CreateBrushFromVisual(Visual visual, double desiredWidth, double desiredHeight)
{
if (visual == null)
{
throw new ArgumentNullException("visual");
}
var target = new RenderTargetBitmap(Convert.ToInt32(desiredWidth), Convert.ToInt32(desiredHeight), 96, 96, PixelFormats.Pbgra32);
target.Render(visual);
var brush = new ImageBrush(target);
brush.Freeze();
return(brush);
}
private void ApplyStyle(Shape shape, bool fillShape)
{
if (_currentState.CurrentPen == null)
{
// Stock Pen
var newBrush = new SolidColorBrush(Colors.Black);
#if !NETFX_CORE
newBrush.Freeze();
#endif
shape.Stroke = newBrush;
shape.StrokeThickness = 1;
}
else
{
LogPen currentPen = _currentState.CurrentPen;
if (currentPen.Width > 0)
{
shape.StrokeThickness = ScaleWidth(currentPen.Width);
}
// Style
if ((PenStyle)(currentPen.Style & 0x000F) == PenStyle.PS_NULL)
{
// Do nothing, null is the default
//shape.Stroke = null;
}
else
{
var newBrush = new SolidColorBrush(currentPen.Colour);
#if !NETFX_CORE
newBrush.Freeze();
#endif
shape.Stroke = newBrush;
if ((PenStyle)(currentPen.Style & 0x000F) == PenStyle.PS_DASH)
{
shape.StrokeDashArray.Add(30);
shape.StrokeDashArray.Add(10);
}
else if ((PenStyle)(currentPen.Style & 0x000F) == PenStyle.PS_DASHDOT)
{
shape.StrokeDashArray.Add(30);
shape.StrokeDashArray.Add(10);
shape.StrokeDashArray.Add(10);
shape.StrokeDashArray.Add(10);
shape.StrokeDashArray.Add(10);
shape.StrokeDashArray.Add(10);
}
else if ((PenStyle)(currentPen.Style & 0x000F) == PenStyle.PS_DASHDOTDOT)
{
shape.StrokeDashArray.Add(30);
shape.StrokeDashArray.Add(10);
shape.StrokeDashArray.Add(10);
shape.StrokeDashArray.Add(10);
shape.StrokeDashArray.Add(10);
shape.StrokeDashArray.Add(10);
shape.StrokeDashArray.Add(10);
shape.StrokeDashArray.Add(10);
}
else if ((PenStyle)(currentPen.Style & 0x000F) == PenStyle.PS_DOT)
{
shape.StrokeDashArray.Add(10);
shape.StrokeDashArray.Add(10);
shape.StrokeDashCap = PenLineCap.Round;
}
}
// Join
if ((PenStyle)(currentPen.Style & 0xF000) == PenStyle.PS_JOIN_BEVEL)
{
shape.StrokeLineJoin = PenLineJoin.Bevel;
}
else if ((PenStyle)(currentPen.Style & 0xF000) == PenStyle.PS_JOIN_MITER)
{
// Do nothing, miter is the default
shape.StrokeLineJoin = PenLineJoin.Miter;
if (_miterLimit != 0)
{
shape.StrokeMiterLimit = _miterLimit;
}
}
else if ((PenStyle)(currentPen.Style & 0xF000) == PenStyle.PS_JOIN_ROUND)
{
shape.StrokeLineJoin = PenLineJoin.Round;
}
// End cap
if ((PenStyle)(currentPen.Style & 0x0F00) == PenStyle.PS_ENDCAP_FLAT)
{
// Do nothing, flat is the default
// shape.StrokeEndLineCap = PenLineCap.Flat;
// shape.StrokeStartLineCap = PenLineCap.Flat;
}
else if ((PenStyle)(currentPen.Style & 0x0F00) == PenStyle.PS_ENDCAP_SQUARE)
{
shape.StrokeEndLineCap = PenLineCap.Square;
shape.StrokeStartLineCap = PenLineCap.Square;
}
else if ((PenStyle)(currentPen.Style & 0x0F00) == PenStyle.PS_ENDCAP_ROUND)
{
shape.StrokeEndLineCap = PenLineCap.Round;
shape.StrokeStartLineCap = PenLineCap.Round;
}
}
if (_currentState.CurrentBrush == null & fillShape)
{
// Stock brush
var newBrush = new SolidColorBrush(Colors.White);
#if !NETFX_CORE
newBrush.Freeze();
#endif
shape.Fill = newBrush;
}
else if (fillShape)
{
LogBrush currentBrush = _currentState.CurrentBrush;
if (currentBrush.Style == BrushStyle.BS_NULL)
{
// Do nothing, null is the default
// shape.Fill = null;
}
else if (currentBrush.Image != null)
{
#if !NETFX_CORE
var imgBrush = new ImageBrush
{
ImageSource = currentBrush.Image,
Stretch = Stretch.None,
TileMode = TileMode.Tile,
Viewport =
new Rect(0, 0, ScaleWidth(currentBrush.Image.Width),
ScaleHeight(currentBrush.Image.Height)),
ViewportUnits = BrushMappingMode.Absolute,
Viewbox =
new Rect(0, 0, ScaleWidth(currentBrush.Image.Width),
ScaleHeight(currentBrush.Image.Height)),
ViewboxUnits = BrushMappingMode.Absolute
};
imgBrush.Freeze();
shape.Fill = imgBrush;
#endif
// TODO: Figure out a way to stop the tile anti-aliasing
}
else if (currentBrush.Style == BrushStyle.BS_PATTERN
| currentBrush.Style == BrushStyle.BS_DIBPATTERN
| currentBrush.Style == BrushStyle.BS_DIBPATTERNPT)
{
var newBrush = new SolidColorBrush(Colors.Black);
#if !NETFX_CORE
newBrush.Freeze();
#endif
shape.Fill = newBrush;
}
else if (currentBrush.Style == BrushStyle.BS_HATCHED)
{
#if !NETFX_CORE
var patternBrush = new VisualBrush();
var patternTile = new Canvas();
var stroke1 = new Path();
var stroke2 = new Path();
var figure1 = new PathFigure();
var figure2 = new PathFigure();
var segments1 = new PathSegmentCollection();
var segments2 = new PathSegmentCollection();
patternBrush.TileMode = TileMode.Tile;
patternBrush.Viewport = new Rect(0, 0, 10, 10);
patternBrush.ViewportUnits = BrushMappingMode.Absolute;
patternBrush.Viewbox = new Rect(0, 0, 10, 10);
patternBrush.ViewboxUnits = BrushMappingMode.Absolute;
stroke1.Data = new PathGeometry();
stroke2.Data = new PathGeometry();
switch (currentBrush.Hatch)
{
case HatchStyle.HS_BDIAGONAL:
// A 45-degree upward, left-to-right hatch.
figure1.StartPoint = new Point(0, 10);
var up45Segment = new LineSegment
{
Point = new Point(10, 0)
};
segments1.Add(up45Segment);
figure1.Segments = segments1;
((PathGeometry)stroke1.Data).Figures.Add(figure1);
patternTile.Children.Add(stroke1);
break;
case HatchStyle.HS_CROSS:
// A horizontal and vertical cross-hatch.
figure1.StartPoint = new Point(5, 0);
figure2.StartPoint = new Point(0, 5);
var downXSegment = new LineSegment
{
Point = new Point(5, 10)
};
segments1.Add(downXSegment);
figure1.Segments = segments1;
var rightXSegment = new LineSegment
{
Point = new Point(10, 5)
};
segments2.Add(rightXSegment);
figure1.Segments = segments1;
figure2.Segments = segments2;
((PathGeometry)stroke1.Data).Figures.Add(figure1);
((PathGeometry)stroke2.Data).Figures.Add(figure2);
patternTile.Children.Add(stroke1);
patternTile.Children.Add(stroke2);
break;
case HatchStyle.HS_DIAGCROSS:
// A 45-degree crosshatch.
figure1.StartPoint = new Point(0, 0);
figure2.StartPoint = new Point(0, 10);
var downDXSegment = new LineSegment
{
Point = new Point(10, 10)
};
segments1.Add(downDXSegment);
figure1.Segments = segments1;
var rightDXSegment = new LineSegment
{
Point = new Point(10, 0)
};
segments2.Add(rightDXSegment);
figure1.Segments = segments1;
figure2.Segments = segments2;
((PathGeometry)stroke1.Data).Figures.Add(figure1);
((PathGeometry)stroke2.Data).Figures.Add(figure2);
patternTile.Children.Add(stroke1);
patternTile.Children.Add(stroke2);
break;
case HatchStyle.HS_FDIAGONAL:
// A 45-degree downward, left-to-right hatch.
figure1.StartPoint = new Point(0, 0);
var down45Segment = new LineSegment
{
Point = new Point(10, 10)
};
segments1.Add(down45Segment);
figure1.Segments = segments1;
((PathGeometry)stroke1.Data).Figures.Add(figure1);
patternTile.Children.Add(stroke1);
break;
case HatchStyle.HS_HORIZONTAL:
// A horizontal hatch.
figure1.StartPoint = new Point(0, 10);
var bottomSegment = new LineSegment
{
Point = new Point(10, 10)
};
segments1.Add(bottomSegment);
figure1.Segments = segments1;
((PathGeometry)stroke1.Data).Figures.Add(figure1);
patternTile.Children.Add(stroke1);
break;
case HatchStyle.HS_VERTICAL:
// A vertical hatch.
figure1.StartPoint = new Point(10, 0);
var verticalSegment = new LineSegment
{
Point = new Point(10, 10)
};
segments1.Add(verticalSegment);
figure1.Segments = segments1;
((PathGeometry)stroke1.Data).Figures.Add(figure1);
patternTile.Children.Add(stroke1);
break;
}
patternBrush.Visual = patternTile;
//patternBrush.Freeze(); // Cant freeze a visual brush
shape.Fill = patternBrush;
#endif
}
else
{
var newBrush = new SolidColorBrush(currentBrush.Colour);
#if !NETFX_CORE
newBrush.Freeze();
#endif
shape.Fill = newBrush;
}
}
}