public SimpleD3D11Renderer(ID3D11Context context, BrushCache brushCache, TextFormatCache textFormatCache) { this.context = context; this.brushCache = brushCache; this.textFormatCache = textFormatCache; }
void MakePen() { SolidColorBrush brush = BrushCache.GetBrush(Colour); pen = new Pen(brush, Thickness); pen.Freeze(); }
public static XamlBrush MapsuiBrushToXaml(Styles.Brush brush, BrushCache brushCache = null) { if (brush == null) return null; switch (brush.FillStyle) { case FillStyle.Cross: return CreateHatchBrush(brush, 12, 10, new List<Geometry> { Geometry.Parse("M 0 0 l 10 10"), Geometry.Parse("M 0 10 l 10 -10") }); case FillStyle.BackwardDiagonal: return CreateHatchBrush(brush, 10, 10, new List<Geometry> { Geometry.Parse("M 0 10 l 10 -10"), Geometry.Parse("M -0.5 0.5 l 10 -10"), Geometry.Parse("M 8 12 l 10 -10") }); case FillStyle.Bitmap: return CreateImageBrush(brush, brushCache); case FillStyle.Dotted: return DottedBrush(brush); case FillStyle.DiagonalCross: return CreateHatchBrush(brush, 10, 10, new List<Geometry> { Geometry.Parse("M 0 0 l 10 10"), Geometry.Parse("M 0 10 l 10 -10") }); case FillStyle.ForwardDiagonal: return CreateHatchBrush(brush, 10, 10, new List<Geometry> { Geometry.Parse("M -1 9 l 10 10"), Geometry.Parse("M 0 0 l 10 10"), Geometry.Parse("M 9 -1 l 10 10") }); case FillStyle.Hollow: return new SolidColorBrush(Colors.Transparent); case FillStyle.Horizontal: return CreateHatchBrush(brush, 10, 10, new List<Geometry> { Geometry.Parse("M 0 5 h 10") }); case FillStyle.Solid: return new SolidColorBrush(brush.Color != null ? brush.Color.ToXaml() : brush.Background != null ? brush.Color.ToXaml() : Colors.Transparent); case FillStyle.Vertical: return CreateHatchBrush(brush, 10, 10, new List<Geometry> { Geometry.Parse("M 5 0 l 0 10") }); default: return (brush.Color != null) ? new SolidColorBrush(brush.Color.ToXaml()) : null; } }
public static XamlShapes.Shape RenderPoint(Point point, IStyle style, IViewport viewport, BrushCache brushCache = null) { XamlShapes.Shape symbol; var matrix = XamlMedia.Matrix.Identity; if (style is SymbolStyle) { var symbolStyle = style as SymbolStyle; if (symbolStyle.BitmapId < 0) symbol = CreateSymbolFromVectorStyle(symbolStyle, symbolStyle.Opacity, symbolStyle.SymbolType); else symbol = CreateSymbolFromBitmap(symbolStyle.BitmapId, symbolStyle.Opacity, brushCache); matrix = CreatePointSymbolMatrix(viewport.Resolution, symbolStyle); } else { symbol = CreateSymbolFromVectorStyle((style as VectorStyle) ?? new VectorStyle()); MatrixHelper.ScaleAt(ref matrix, viewport.Resolution, viewport.Resolution); } MatrixHelper.Append(ref matrix, GeometryRenderer.CreateTransformMatrix(point, viewport)); symbol.RenderTransform = new XamlMedia.MatrixTransform {Matrix = matrix}; symbol.IsHitTestVisible = false; return symbol; }
public D3D11Renderer(ID3D11Context context, BrushCache brushCache, TextFormatCache textFormatCache, D3D11TextureManager9 textureManager) { this.context = context; this.brushCache = brushCache; this.textFormatCache = textFormatCache; this.textureManager = textureManager; context.Draw += this.OnDraw; }
public SolidColorBrush GetBrush(string name) { InitAliasColorMappings(); var mapping = _aliasToColorMapping[name]; return(BrushCache.GetBrush(mapping.Color)); }
void ShowWatermark() { if (string.IsNullOrEmpty(Text) && !string.IsNullOrEmpty(Watermark)) { isWatermarked = true; //save the existing binding so it can be restored textBinding = BindingOperations.GetBinding(this, TextProperty); //blank out the existing binding so we can throw in our Watermark BindingOperations.ClearBinding(this, TextProperty); //set the signature watermark gray Foreground = BrushCache.GetBrush(Colors.LightGray); //display our watermark text Text = Watermark; } }
public object?Convert(object value, Type targetType, object parameter, CultureInfo culture) { if (value == null) { return(null); } // For a more sophisticated converter, check also the targetType and react accordingly.. if (value is Color color) { return(BrushCache.GetBrush(color)); } // Could support more source types if wish Type type = value.GetType(); throw new InvalidOperationException("Unsupported type [" + type.Name + "]"); }
public NodeControl() { InitializeComponent(); // set the default handler for adding edges edgeAddingHandler = delegate(NodeBase from, NodeBase to) { EdgeBase edge = new Edge(from, to); myCanvas.AddEdge(edge); }; newEdgePen = new Pen(BrushCache.GetBrush(Colors.White), 3); newEdgePen.Freeze(); marqueePen = new Pen(BrushCache.GetBrush(Colors.White), 3); marqueePen.Freeze(); marqueeFill = BrushCache.GetBrush(Color.FromArgb(50, 255, 255, 255)); ResetView(); }
internal void Render(Graphics Device) { Executor_.SetDevice(Device); WinConvert.SetDevice(Device); LGui.Begin(); if (DemoIndex_ != -1) { DemoList_[DemoIndex_].Render(); } else { Device.FillRectangle(BrushCache.GetOrCreate(LGuiColor.Red), 0, 0, WinSize.X, WinSize.Y); } LGui.End(); Device.DrawString($"DrawCall : {LGui.GetDrawCall()}", TextFont_, Brushes.White, 800, 520); }
public SolidColorBrush GetBrush(string name) { InitAliasColorMappings(); if (string.IsNullOrEmpty(name)) { // Default color for example the unused space in knowledge loss return(DefaultDrawingPrimitives.DefaultBrush); } if (_aliasToColorMapping.ContainsKey(name) is false) { // A developer name is not known! This should not happen. Debug.WriteLine($"No color mapping found for developer {name}"); return(Brushes.Black); } var mapping = _aliasToColorMapping[name]; return(BrushCache.GetBrush(mapping.Color)); }
private RectangleF DrawStringPart(CharacterRange range, Graphics g, string str, Style style, float offset) { string part = str.Substring(range.First, range.Length); UpdateTabStop(part, style); RectangleF size = MeasureStringPart(range, g, str, style); if (!style.Background.IsEmpty) { RectangleF textRect = size; textRect.X = 0; textRect.Offset(offset, 0); g.FillRectangle(BrushCache.getSolid(style.Background), textRect); } g.DrawString(part, FontCache.get(style), BrushCache.getForeground(style), offset, 0, stringFormat); return(size); }
public SimpleRenderer() { switch (Drawing.RenderMode) { case RenderMode.Dx9: { var context = new D3D9Context(); var font = new FontCache(context); this.active = new SimpleD3D9Renderer(context, font); break; } case RenderMode.Dx11: { var context = new D3D11Context(); var brush = new BrushCache(context); var text = new TextFormatCache(context); this.active = new SimpleD3D11Renderer(context, brush, text); break; } } }
/// <summary> /// Initializes a new instance of the <see cref="NeovimControl"/> class. /// </summary> /// <param name="parent">The parent control.</param> /// <param name="neovimClient">the neovim client.</param> public NeovimControl(IElement parent, NeovimClient.NeovimClient neovimClient) : base(parent) { this.neovimClient = neovimClient; this.neovimClient.Redraw += this.Invalidate; this.neovimClient.FontChanged += this.OnFontChanged; this.textAnalyzer = new DWrite.TextAnalyzer(this.factoryDWrite); this.cursorEffects = new CursorEffects(this.DeviceContext); this.brushCache = new BrushCache(); this.scriptAnalysesCache = new ScriptAnalysesCache(); this.fontCache = new FontCache(this.factoryDWrite); this.textParam = new TextLayoutParameters( this.factoryDWrite, "Consolas", 11, false, false, false, false, this.Factory.DesktopDpi); }
public MyCanvas() { IsHitTestVisible = false; TransformGroup transforms = new TransformGroup(); transforms.Children.Add(translate); transforms.Children.Add(scale); //RenderTransformOrigin = new Point(0.5, 0.5); RenderTransform = transforms; quadTree = new QuadTree(); Physics = new ForceDirectedPhysics(); whiteBrush = BrushCache.GetBrush(Colors.White); fontColour = BrushCache.GetBrush(Colors.White); if (DesignerProperties.GetIsInDesignMode(this)) { return; } DispatcherTimer timer = new DispatcherTimer(DispatcherPriority.Render); timer.Interval = TimeSpan.FromMilliseconds(16); timer.Tick += timer_Tick; timer.Start(); Thread physicsThread = new Thread(RunPhysics); physicsThread.IsBackground = true; //physicsThread.Start(); SizeChanged += MyCanvas_SizeChanged; }
public static Media.Brush ToXaml(this Brush brush, BrushCache brushCache = null) { return(StyleConverter.MapsuiBrushToXaml(brush, brushCache)); }
public static Media.Brush ToXaml(this Brush brush, BrushCache brushCache = null) { return StyleConverter.MapsuiBrushToXaml(brush, brushCache); }
private static ImageBrush CreateImageBrush(Styles.Brush brush, BrushCache brushCache = null) { return brushCache != null ? brushCache.GetImageBrush(brush.BitmapId, CreateImageBrush) : CreateImageBrush(BitmapRegistry.Instance.Get(brush.BitmapId)); }
public static XamlShapes.Shape RenderPolygon(Polygon polygon, IStyle style, IViewport viewport, BrushCache brushCache = null) { if (!(style is VectorStyle)) throw new ArgumentException("Style is not of type VectorStyle"); var vectorStyle = style as VectorStyle; XamlShapes.Path path = CreatePolygonPath(vectorStyle, viewport.Resolution, brushCache); path.Data = polygon.ToXaml(); var matrixTransform = new XamlMedia.MatrixTransform { Matrix = CreateTransformMatrix1(viewport) }; path.RenderTransform = matrixTransform; if (path.Fill != null) path.Fill.Transform = matrixTransform.Inverse as XamlMedia.MatrixTransform; path.UseLayoutRounding = true; return path; }
private static Canvas RenderVectorLayer(IViewport viewport, ILayer layer, bool rasterizing = false) { // todo: // find solution for try catch. Sometimes this method will throw an exception // when clearing and adding features to a layer while rendering var canvas = new Canvas { Opacity = layer.Opacity, IsHitTestVisible = false }; try { var features = layer.GetFeaturesInView(viewport.Extent, viewport.RenderResolution).ToList(); var layerStyles = BaseLayer.GetLayerStyles(layer); var brushCache = new BrushCache(); foreach (var layerStyle in layerStyles) { var style = layerStyle; // This is the default that could be overridden by an IThemeStyle foreach (var feature in features) { if (layerStyle is IThemeStyle) style = (layerStyle as IThemeStyle).GetStyle(feature); if ((style == null) || (style.Enabled == false) || (style.MinVisible > viewport.Resolution) || (style.MaxVisible < viewport.Resolution)) continue; RenderFeature(viewport, canvas, feature, style, rasterizing, brushCache); } } foreach (var feature in features) { var styles = feature.Styles ?? Enumerable.Empty<IStyle>(); foreach (var style in styles) if ((feature.Styles != null) && style.Enabled) RenderFeature(viewport, canvas, feature, style, rasterizing, brushCache); } return canvas; } catch (Exception ex) { Logger.Log(LogLevel.Error, "Unexpected error in renderer", ex); return canvas; // If exception happens inside RenderFeature function after // at -least one child has been added to the canvas, // returning new canvas will leave the previously created (but // not yet added to parent canvas) canvas abandoned, that will // cause the exception when resuing RenderedGeometry object, because // at -least one RenderedGeometry was attached to that abandoned canvas. // returning the same canvas will solve this error, as it will // be clear this canvas childs on next render call. // return new Canvas { IsHitTestVisible = false }; } }
private static Shape RenderGeometry(IViewport viewport, IStyle style, IFeature feature, BrushCache brushCache = null) { if (feature.Geometry is Geometries.Point) return PointRenderer.RenderPoint(feature.Geometry as Geometries.Point, style, viewport, brushCache); if (feature.Geometry is MultiPoint) return GeometryRenderer.RenderMultiPoint(feature.Geometry as MultiPoint, style, viewport); if (feature.Geometry is LineString) return GeometryRenderer.RenderLineString(feature.Geometry as LineString, style, viewport); if (feature.Geometry is MultiLineString) return GeometryRenderer.RenderMultiLineString(feature.Geometry as MultiLineString, style, viewport); if (feature.Geometry is Polygon) return GeometryRenderer.RenderPolygon(feature.Geometry as Polygon, style, viewport, brushCache); if (feature.Geometry is MultiPolygon) return GeometryRenderer.RenderMultiPolygon(feature.Geometry as MultiPolygon, style, viewport); if (feature.Geometry is IRaster) return GeometryRenderer.RenderRaster(feature.Geometry as IRaster, style, viewport); return null; }
private static void RenderFeature(IViewport viewport, Canvas canvas, IFeature feature, IStyle style, bool rasterizing, BrushCache brushCache = null) { if (style is LabelStyle) { var labelStyle = (LabelStyle) style; canvas.Children.Add(SingleLabelRenderer.RenderLabel(feature.Geometry.GetBoundingBox().GetCentroid(), labelStyle, viewport, labelStyle.GetLabelText(feature))); } else { var renderedGeometry = feature.RenderedGeometry.ContainsKey(style) ? feature.RenderedGeometry[style] as Shape : null; if (renderedGeometry == null) { renderedGeometry = RenderGeometry(viewport, style, feature, brushCache); if (!rasterizing) feature.RenderedGeometry[style] = renderedGeometry; } else { PositionGeometry(renderedGeometry, viewport, style, feature); } if (!canvas.Children.Contains(renderedGeometry)) // Adding twice can happen when a single feature has two identical styles canvas.Children.Add(renderedGeometry); } }
private static XamlShapes.Path CreatePolygonPath(VectorStyle style, double resolution, BrushCache brushCache = null) { var path = new XamlShapes.Path(); if (style.Outline != null) { path.Stroke = new XamlMedia.SolidColorBrush(style.Outline.Color.ToXaml()); path.StrokeThickness = style.Outline.Width * resolution; path.StrokeDashArray = style.Outline.PenStyle.ToXaml(); path.Tag = style.Outline.Width; // see #linewidthhack } path.Fill = style.Fill.ToXaml(brushCache); path.IsHitTestVisible = false; return path; }
static GraphItem() { highlightBrush = BrushCache.GetBrush(Color.FromArgb(150, 255, 255, 0)); }
private static XamlShapes.Shape CreateSymbolFromBitmap(int bmpId, double opacity, BrushCache brushCache = null) { XamlMedia.ImageBrush imageBrush; if (brushCache == null) { var data = BitmapRegistry.Instance.Get(bmpId); var bitmapImage = data.CreateBitmapImage(); imageBrush = new XamlMedia.ImageBrush {ImageSource = bitmapImage}; } else { imageBrush = brushCache.GetImageBrush(bmpId); } // note: It probably makes more sense to use PixelWith here: var width = imageBrush.ImageSource.Width; var height = imageBrush.ImageSource.Height; var path = new XamlShapes.Path { Data = new XamlMedia.RectangleGeometry { Rect = new Rect(-width*0.5, -height*0.5, width, height) }, Fill = imageBrush, Opacity = opacity }; return path; }
protected override void OnColourChanged() { brush = BrushCache.GetBrush(Colour); }
private void UpdateText() { formattedText = new FormattedText("text!", CultureInfo.CurrentCulture, FlowDirection.LeftToRight, new Typeface("Helvetica"), 12, BrushCache.GetBrush(Colors.White)); }