public static Brush SetBrightness(this Brush original, double brightness)
{
if (brightness < 0 || brightness > 1)
{
throw new ArgumentOutOfRangeException("brightness", "brightness should be between 0 and 1");
}
Brush result;
if (original is SolidColorBrush)
{
HSBColor hsb = HSBColor.FromColor(((SolidColorBrush)original).Color);
hsb.B = brightness;
result = new SolidColorBrush(hsb.ToColor());
}
else if (original is GradientBrush)
{
result = original.Clone();
// change brightness of every gradient stop
foreach (GradientStop gs in ((GradientBrush)result).GradientStops)
{
HSBColor hsb = HSBColor.FromColor(gs.Color);
hsb.B = brightness;
gs.Color = hsb.ToColor();
}
}
else
{
result = original.Clone();
}
return(result);
}
private static Brush NormalizeBrush(Brush brush, IRectangle layout)
{
if (brush is LinearGradientBrush)
{
LinearGradientBrush lgb = (LinearGradientBrush)brush.Clone();
lgb.MultiplyTransform(
new Matrix(Math.Max(0.1f, (float)layout.Width), 0, 0, Math.Max(0.1f, (float)layout.Height),
(float)layout.X, (float)layout.Y), MatrixOrder.Append);
brush = lgb;
}
else if (brush is PathGradientBrush)
{
PathGradientBrush pgb = (PathGradientBrush)brush.Clone();
pgb.MultiplyTransform(
new Matrix(Math.Max(0.1f, (float)layout.Width), 0, 0, Math.Max(0.1f, (float)layout.Height),
(float)layout.X, (float)layout.Y), MatrixOrder.Append);
brush = pgb;
}
else if (brush is TextureBrush)
{
TextureBrush tb = (TextureBrush)brush.Clone();
tb.MultiplyTransform(
new Matrix(Math.Max(0.1f, (float)layout.Width), 0, 0, Math.Max(0.1f, (float)layout.Height),
(float)layout.X, (float)layout.Y), MatrixOrder.Append);
brush = tb;
}
return(brush);
}
private void FillCanvas()
{
cnvDrawArea.Background = uscColorPicker.elpCurrentColor.Fill.Clone();
nextAction = NextAction.DRAW;
btnBucket.Background = originalButtonColor.Clone();
var color = ((Color)uscColorPicker.elpCurrentColor.Fill.GetValue(SolidColorBrush.ColorProperty));
Client.WriteFillMessage(color.ToString());
}
public void Kirmizi1()
{
btnKirmizi1.Dispatcher.Invoke(() =>
{
btnKirmizi1.Background = Brushes.Green;
});
Thread.Sleep(500);
btnKirmizi1.Dispatcher.Invoke(() =>
{
btnKirmizi1.Background = Kirmizi.Clone();
});
}
static SnapToGridRenderer()
{
Brush brush = (Brush) new SolidColorBrush(Color.FromScRgb(1f, 0.125f, 0.125f, 0.125f));
SnapToGridRenderer.brushOne = brush.Clone();
SnapToGridRenderer.brushOne.Opacity = 0.1;
SnapToGridRenderer.brushOne.Freeze();
SnapToGridRenderer.brushFive = brush.Clone();
SnapToGridRenderer.brushFive.Opacity = 0.25;
SnapToGridRenderer.brushFive.Freeze();
SnapToGridRenderer.brushTen = brush.Clone();
SnapToGridRenderer.brushTen.Opacity = 0.5;
SnapToGridRenderer.brushTen.Freeze();
}
public DrawEventArgs(DrawingMode drawingMode, List <PointLatLng> drawingPoints, Pen stroke, Brush fill)
{
DrawingMode = drawingMode;
if (drawingMode == DrawingMode.Polygon)
{
Polygon = new GMapDrawPolygon(drawingPoints, drawingMode.ToString());
if (fill != null)
{
Polygon.Fill = (Brush)fill.Clone();
}
if (stroke != null)
{
Polygon.Stroke = (Pen)stroke.Clone();
}
Polygon.IsHitTestVisible = true;
}
else if (drawingMode == DrawingMode.Rectangle)
{
Rectangle = new GMapDrawRectangle(drawingPoints, drawingMode.ToString());
if (fill != null)
{
Rectangle.Fill = (Brush)fill.Clone();
}
if (stroke != null)
{
Rectangle.Stroke = (Pen)stroke.Clone();
}
Rectangle.IsHitTestVisible = true;
}
else if (drawingMode == DrawingMode.Route)
{
Route = new GMapDrawRoute(drawingPoints, drawingMode.ToString());
if (stroke != null)
{
Route.Stroke = (Pen)stroke.Clone();
}
Route.IsHitTestVisible = true;
}
else if (drawingMode == DrawingMode.Line)
{
Line = new GMapDrawLine(drawingPoints, drawingMode.ToString());
if (stroke != null)
{
Line.Stroke = (Pen)stroke.Clone();
}
Line.IsHitTestVisible = true;
}
}
/// <summary>
/// Updates properties from a change to the format map. Also forces a redraw of all the time stamped lines.
/// </summary>
private void SetFontFromClassification()
{
var font = _formatMap.GetTextProperties(_lineNumberClassification);
_showHours = _textView.Options.GetOptionValue(TimeStampMarginShowHours.StaticKey);
_showMilliseconds = _textView.Options.GetOptionValue(TimeStampMarginShowMilliseconds.StaticKey);
// In the line number margin, we always enforce a 100% opacity.
// This is to prevent mixing of the line number's background color
// with its parent's background when the background brush of the
// line number classified item is not opaque.
Brush backgroundBrush = font.BackgroundBrush;
if (backgroundBrush.Opacity != 1.0)
{
backgroundBrush = backgroundBrush.Clone();
backgroundBrush.Opacity = 1.0;
backgroundBrush.Freeze();
font = font.SetBackgroundBrush(backgroundBrush);
}
base.Background = backgroundBrush;
_formatting = font;
this.SetClearTypeHint(font);
this.DetermineMarginWidth();
// Reformat all the lines
_translatedCanvas.Children.Clear();
this.UpdateLineNumbers();
}
public void setBrush(Brush _brush)
{
fillBrush = (Brush)_brush.Clone();
SolidBrush brush = (SolidBrush)_brush;
fillColor = brush.Color;
}
public Brush InterpolateValue(Brush from, Brush to, double progress)
{
Brush result = from.Clone();
InterpolateResult((TBrush)result, (TBrush)from, (TBrush)to, progress);
return(result);
}
public Brush ScaleValue(Brush value, double factor)
{
Brush result = value.Clone();
ScaleResult((TBrush)result, factor);
return(result);
}
public Brush SubtractValues(Brush a, Brush b)
{
Brush result = a.Clone();
SubtractValuesFromResult((TBrush)result, (TBrush)a, (TBrush)b);
return(result);
}
// For the animations to work, the brushes (each object really) must be cloned,
// since working on reference types would yield incorrect results.
// -> These methods clone the brushes, but delegate the actual value
// modification to the methods below.
public Brush AddValues(Brush a, Brush b)
{
Brush result = a.Clone();
AddValuesToResult((TBrush)result, (TBrush)a, (TBrush)b);
return(result);
}
/// <summary>
/// Constructor that creates a <see cref="Brush"/> fill, using a user-supplied, custom
/// <see cref="Brush"/>. The brush will be scaled to fit the destination screen object
/// unless you manually change <see cref="IsScaled"/> to false;
/// </summary>
/// <param name="brush">The <see cref="Brush"/> to use for fancy fills. Typically, this would
/// be a <see cref="LinearGradientBrush"/> or a <see cref="TextureBrush"/> class</param>
public Fill(Brush brush)
{
Init();
this.color = Color.White;
this.brush = (Brush)brush.Clone();
this.type = FillType.Brush;
}
public void SetStroke(Brush brush)
{
foreach (var o in objects)
{
o.SetStroke(brush.Clone());
}
}
/// <summary>
/// Creates a material with the specified diffuse, emissive and specular brushes.
/// </summary>
/// <param name="diffuse">The diffuse color.</param>
/// <param name="emissive">The emissive color.</param>
/// <param name="specular">The specular color.</param>
/// <param name="opacity">The opacity.</param>
/// <param name="specularPower">The specular power.</param>
/// <returns>The material.</returns>
public static Material CreateMaterial(
Brush diffuse, Brush emissive, Brush specular = null, double opacity = 1, double specularPower = 85)
{
var mg = new MaterialGroup();
if (diffuse != null)
{
diffuse = diffuse.Clone();
diffuse.Opacity = opacity;
mg.Children.Add(new DiffuseMaterial(diffuse));
}
if (emissive != null)
{
emissive = emissive.Clone();
emissive.Opacity = opacity;
mg.Children.Add(new EmissiveMaterial(emissive));
}
if (specular != null)
{
specular = specular.Clone();
specular.Opacity = opacity;
mg.Children.Add(new SpecularMaterial(specular, specularPower));
}
return(mg);
}
public override void setBrush(int argb, int style)
{
byte alpha = (byte)((argb >> 24) & 0xFF);
if (style == 0)
{
if (alpha == 0)
{
_brush = null;
}
else
{
if (_brush != null && _brush is SolidColorBrush)
{
_brush = _brush.Clone();
(_brush as SolidColorBrush).Color = toColor(argb);
}
else
{
_brush = new SolidColorBrush(toColor(argb));
}
_brush.Freeze();
}
}
}
private void btnOK_Click(object sender, RoutedEventArgs e)
{
CurrentBrush.CurBrushType = BrushType.Pattern;
CurrentBrush.Brush = tempBrush.Clone();
CurrentBrush.Brush.Opacity = MainWindow.mainWindow.GetSlider().Value / 100;
this.Close();
}
void InitializeBrushes(out Brush brush, out Brush overwriteBrush, VSTC.IClassificationType classificationType)
{
var props = classificationFormatMap.GetTextProperties(classificationType);
if (!props.BackgroundBrushEmpty)
{
brush = props.BackgroundBrush;
}
else
{
Debug.Assert(!classificationFormatMap.DefaultTextProperties.ForegroundBrushEmpty);
brush = classificationFormatMap.DefaultTextProperties.ForegroundBrush;
if (classificationFormatMap.DefaultTextProperties.ForegroundBrushEmpty)
{
brush = Brushes.Black;
}
}
if (brush.CanFreeze)
{
brush.Freeze();
}
overwriteBrush = brush.Clone();
overwriteBrush.Opacity = 0.5;
if (overwriteBrush.CanFreeze)
{
overwriteBrush.Freeze();
}
}
public void Commit()
{
if (Brush != null)
{
Property.Value = Brush.Clone();
}
}
protected override void OnRender(DrawingContext drawingContext)
{
base.OnRender(drawingContext);
Debug.Assert((overwriteCaretBrush == null) == (caretBrush == null));
if (caretBrush == null)
{
caretBrush = classificationFormatMap.DefaultTextProperties.ForegroundBrush;
Debug.Assert(!classificationFormatMap.DefaultTextProperties.ForegroundBrushEmpty);
if (classificationFormatMap.DefaultTextProperties.ForegroundBrushEmpty)
{
caretBrush = Brushes.Black;
}
caretBrush = caretBrush.Clone();
overwriteCaretBrush = caretBrush.Clone();
overwriteCaretBrush.Opacity = 0.5;
if (caretBrush.CanFreeze)
{
caretBrush.Freeze();
}
if (overwriteCaretBrush.CanFreeze)
{
overwriteCaretBrush.Freeze();
}
}
drawingContext.DrawGeometry(caretGeometry.IsOverwriteMode ? overwriteCaretBrush : caretBrush, null, caretGeometry.Geometry);
}
public static Brush ChangeBrushOpacity(Brush input, double opacity)
{
Brush output = input.Clone();
output.Opacity = opacity;
return(output);
}
public override void OnRender(ChartControl chartControl, ChartScale chartScale)
{
if (firstTime && DrawingState == DrawingState.Normal)
{
firstTime = false;
Cbi.License.Log("Polygon");
}
RenderTarget.AntialiasMode = SharpDX.Direct2D1.AntialiasMode.PerPrimitive;
Stroke outlineStroke = OutlineStroke;
outlineStroke.RenderTarget = RenderTarget;
ChartPanel chartPanel = chartControl.ChartPanels[PanelIndex];
// dont bother with an area brush if we're doing a hit test (software) render pass. we do not render area then.
// this allows us to select something behind our area brush (like NT7)
if (!IsInHitTest && AreaBrush != null)
{
if (areaBrushDevice.Brush == null)
{
Brush brushCopy = areaBrush.Clone();
brushCopy.Opacity = areaOpacity / 100d;
areaBrushDevice.Brush = brushCopy;
}
areaBrushDevice.RenderTarget = RenderTarget;
}
else
{
areaBrushDevice.RenderTarget = null;
areaBrushDevice.Brush = null;
}
// align to full pixel to avoid unneeded aliasing
double strokePixAdjust = outlineStroke.Width % 2 == 0 ? 0.5d : 0d;
// always re-create polygon geometry here
SharpDX.Direct2D1.PathGeometry polyGeo = CreatePolygonGeometry(chartControl, chartPanel, chartScale, strokePixAdjust);
if (DrawingState != DrawingState.Building)
{
if (!IsInHitTest && areaBrushDevice.BrushDX != null)
{
RenderTarget.FillGeometry(polyGeo, areaBrushDevice.BrushDX);
}
else
{
// Polygon can be selected by center anchor point still, so give something for the hit test pass to
// detect we want to be hit test there, so draw a rect in center. actual brush doesnt matter
Point[] points = GetPolygonAnchorPoints(chartControl, chartScale, true);
Point centroid = points.Length > 0 ? points.Last() : new Point();
RenderTarget.FillRectangle(new SharpDX.RectangleF((float)centroid.X - 5f, (float)centroid.Y - 5f, (float)cursorSensitivity, (float)cursorSensitivity), chartControl.SelectionBrush);
}
}
SharpDX.Direct2D1.Brush tmpBrush = IsInHitTest ? chartControl.SelectionBrush : outlineStroke.BrushDX;
RenderTarget.DrawGeometry(polyGeo, tmpBrush, outlineStroke.Width, outlineStroke.StrokeStyle);
polyGeo.Dispose();
}
public ColorData(Pen pen, Brush brush)
{
Pen = (Pen)pen.Clone();
Brush = (Brush)brush.Clone();
_color = Pen.Color;
_width = (int)Pen.Width;
_fillColor = ((SolidBrush)Brush).Color;
}
/// <summary>
/// Called after the <see cref="CenterLineBrush"/> value has changed.
/// </summary>
/// <param name="oldValue">The previous value of <see cref="CenterLineBrush"/></param>
/// <param name="newValue">The new value of <see cref="CenterLineBrush"/></param>
protected virtual void OnCenterLineBrushChanged(Brush oldValue, Brush newValue)
{
var frozen = newValue.Clone();
frozen.Freeze();
centerLine.Stroke = frozen;
UpdateWaveform();
}
/// <summary>
/// Constructor that creates a <see cref="Brush"/> fill, using a user-supplied, custom
/// <see cref="Brush"/>. The brush will be scaled to fit the destination screen object
/// according to the <see paramref="isScaled"/> parameter.
/// </summary>
/// <param name="brush">The <see cref="Brush"/> to use for fancy fills. Typically, this would
/// be a <see cref="LinearGradientBrush"/> or a <see cref="TextureBrush"/> class</param>
/// <param name="isScaled">Determines if the brush will be scaled to fit the bounding box
/// of the destination object. true to scale it, false to leave it unscaled</param>
public Fill(Brush brush, bool isScaled)
{
Init();
this.isScaled = isScaled;
this.color = Color.White;
this.brush = (Brush)brush.Clone();
this.type = FillType.Brush;
}
/// <summary>
/// Constructor that creates a <see cref="Brush"/> fill, using a user-supplied, custom
/// <see cref="Brush"/>. The brush will be scaled to fit the destination screen object
/// according to the <see paramref="isScaled"/> parameter.
/// </summary>
/// <param name="brush">The <see cref="Brush"/> to use for fancy fills. Typically, this would
/// be a <see cref="LinearGradientBrush"/> or a <see cref="TextureBrush"/> class</param>
/// <param name="isScaled">Determines if the brush will be scaled to fit the bounding box
/// of the destination object. true to scale it, false to leave it unscaled</param>
public Fill(Brush brush, bool isScaled)
{
Init();
_isScaled = isScaled;
_color = Color.White;
_brush = (Brush)brush.Clone();
_type = FillType.Brush;
}
private void OnForegroundChanged(Brush newValue)
{
foregroundBrush = newValue.Clone();
foregroundBrush.Freeze();
foregourndPen = new Pen(foregroundBrush, 2);
foregourndPen.Freeze();
}
public void SetSingleBrush(Brush brush)
{
this.Brushes = new Brush[this.Paths.Length];
for (int i = 0; i < this.Brushes.Length; i++)
{
this.Brushes[i] = (Brush)brush.Clone();
}
}
private void OnActiveForegroundChanged(Brush newValue)
{
activeForegourndBrush = newValue.Clone();
activeForegourndBrush.Freeze();
activePen = new Pen(activeForegourndBrush, 2);
activePen.Freeze();
}
public override object Clone()
{
return(new DrawablePath {
Path = Path?.Clone() as GraphicsPath,
Brush = Brush?.Clone() as Brush,
Pen = Pen?.Clone() as Pen
});
}
