public void LoadList(ScatteringPiecesObservable <CA, LI> mod, string tagUsed)
{
EventAggregator thisE = Resolve <EventAggregator>();
thisE.Subscribe(this);
SetBinding(TextProperty, nameof(ScatteringPiecesObservable <CA, LI> .TextToAppear));
SetBinding(IsEnabledProperty, nameof(ScatteringPiecesObservable <CA, LI> .IsEnabled));
_thisMod = mod;
DataContext = _thisMod; // so it can do the text and isenabled.
_tagUsed = tagUsed;
_objectList = mod.RemainingList;
_objectList.CollectionChanged += ObjectList_CollectionChanged;
_thisCanvas = new Canvas();
_thisCanvas.Height = _thisMod.MaxSize.Height;
_thisCanvas.Width = _thisMod.MaxSize.Width;
Grid tirstGrid = new Grid();
tirstGrid.Children.Add(ThisDraw);
ScrollViewer thisScroll = new ScrollViewer();
thisScroll.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;
thisScroll.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
thisScroll.Content = _thisCanvas;
tirstGrid.Children.Add(thisScroll);
if (Text == "" && _thisMod.TextToAppear != "")
{
throw new BasicBlankException("The bindings did not even work for text");
}
var thisRect = ThisFrame.GetControlArea();
thisScroll.Margin = new Thickness(thisRect.Left + 3, thisRect.Top + 3, 3, 5); // try this way.
PopulateCards();
MouseUp += BoneYardWPF_MouseUp;
Content = tirstGrid;
}
protected override void OnApplyTemplate()
{
base.OnApplyTemplate();
_BackgroundCanvas = (Canvas)GetTemplateChild(BackgroundCanvasName);
_TextOverlaysCanvas = (CanvasControl)GetTemplateChild(TextOverlaysCanvasName);
_SelectionHighlightBorder = (Border)GetTemplateChild(SelectionHighlightBorderName);
_CursorIndicatorRectangle = (Rectangle)GetTemplateChild(CursorIndicatorRectangleName);
_SyntaxErrorToolTip = (TeachingTip)GetTemplateChild(SyntaxErrorToolTipName);
ContentScroller = (ScrollViewer)GetTemplateChild(ContentScrollerName);
ContentElement = (ContentPresenter)GetTemplateChild(ContentElementName);
Guard.IsNotNull(_BackgroundCanvas, nameof(BackgroundCanvasName));
Guard.IsNotNull(_TextOverlaysCanvas, nameof(TextOverlaysCanvasName));
Guard.IsNotNull(_SelectionHighlightBorder, nameof(SelectionHighlightBorderName));
Guard.IsNotNull(_CursorIndicatorRectangle, nameof(CursorIndicatorRectangleName));
Guard.IsNotNull(_SyntaxErrorToolTip, SyntaxErrorToolTipName);
Guard.IsNotNull(ContentScroller, ContentScrollerName);
Guard.IsNotNull(ContentElement, ContentElementName);
_BackgroundCanvas.SizeChanged += BackgroundCanvas_SizeChanged;
_TextOverlaysCanvas.CreateResources += _TextOverlaysCanvas_CreateResources;
_TextOverlaysCanvas.Draw += TextOverlaysCanvas_Draw;
_SyntaxErrorToolTip.Closed += delegate { ContentScroller.IsHitTestVisible = true; };
ContentScroller.Loaded += ContentElement_Loaded;
ContentElement.SizeChanged += ContentElement_SizeChanged;
ContentScroller.StartExpressionAnimation(_TextOverlaysCanvas, Axis.X, VisualProperty.Offset);
ContentScroller.StartExpressionAnimation(_TextOverlaysCanvas, Axis.Y, VisualProperty.Offset);
ContentScroller.StartExpressionAnimation(_SelectionHighlightBorder, Axis.Y, VisualProperty.Offset);
ContentScroller.StartExpressionAnimation(_CursorIndicatorRectangle, Axis.X, VisualProperty.Offset);
ContentScroller.StartExpressionAnimation(_CursorIndicatorRectangle, Axis.Y, VisualProperty.Offset);
UpdateVisualElementsOnThemeChanged(SyntaxHighlightTheme);
}
private void Awake()
{
var time = IPA.Utilities.Utils.CanUseDateTimeNowSafely ? DateTime.Now : DateTime.UtcNow;
_jokeTime = (time.Day == 18 && time.Month == 6) || (time.Day == 1 && time.Month == 4);
gameObject.transform.position = Position;
gameObject.transform.eulerAngles = Rotation;
gameObject.transform.localScale = Scale;
_canvas = gameObject.AddComponent<Canvas>();
_canvas.renderMode = RenderMode.WorldSpace;
_canvas.enabled = false;
var rectTransform = _canvas.transform as RectTransform;
rectTransform.sizeDelta = CanvasSize;
_authorNameText = BeatSaberMarkupLanguage.BeatSaberUI.CreateText(_canvas.transform as RectTransform, AuthorNameText, AuthorNamePosition);
rectTransform = _authorNameText.transform as RectTransform;
rectTransform.SetParent(_canvas.transform, false);
rectTransform.anchoredPosition = AuthorNamePosition;
rectTransform.sizeDelta = HeaderSize;
_authorNameText.text = AuthorNameText;
_authorNameText.fontSize = AuthorNameFontSize;
var pluginText = _jokeTime ? "SongCore Cleaner" : PluginNameText;
_pluginNameText = BeatSaberMarkupLanguage.BeatSaberUI.CreateText(_canvas.transform as RectTransform, pluginText, PluginNamePosition);
rectTransform = _pluginNameText.transform as RectTransform;
rectTransform.SetParent(_canvas.transform, false);
rectTransform.sizeDelta = HeaderSize;
rectTransform.anchoredPosition = PluginNamePosition;
_pluginNameText.text = pluginText;
_pluginNameText.fontSize = PluginNameFontSize;
_headerText = BeatSaberMarkupLanguage.BeatSaberUI.CreateText(_canvas.transform as RectTransform, HeaderText, HeaderPosition);
rectTransform = _headerText.transform as RectTransform;
rectTransform.SetParent(_canvas.transform, false);
rectTransform.anchoredPosition = HeaderPosition;
rectTransform.sizeDelta = HeaderSize;
_headerText.text = HeaderText;
_headerText.fontSize = HeaderFontSize;
_loadingBackg = new GameObject("Background").AddComponent<Image>();
rectTransform = _loadingBackg.transform as RectTransform;
rectTransform.SetParent(_canvas.transform, false);
rectTransform.sizeDelta = LoadingBarSize;
_loadingBackg.color = BackgroundColor;
_loadingBar = new GameObject("Loading Bar").AddComponent<Image>();
rectTransform = _loadingBar.transform as RectTransform;
rectTransform.SetParent(_canvas.transform, false);
rectTransform.sizeDelta = LoadingBarSize;
var tex = Texture2D.whiteTexture;
var sprite = Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height), Vector2.one * 0.5f, 100, 1);
_loadingBar.sprite = sprite;
_loadingBar.type = Image.Type.Filled;
_loadingBar.fillMethod = Image.FillMethod.Horizontal;
_loadingBar.color = new Color(1, 1, 1, 0.5f);
DontDestroyOnLoad(gameObject);
}
protected override void OnDraw(Canvas?canvas)
{
base.OnDraw(canvas);
canvas?.DrawBitmap(canvasBitmap !, 0, 0, canvasPaint);
canvas?.DrawPath(drawPath, drawPaint);
}
public Canvas BeginRecording(Rect cullRect)
{
CullRect = cullRect;
RecordingCanvas = new Canvas();
return(RecordingCanvas);
}
protected override void DispatchDraw(Canvas?canvas)
{
if (Clip != null)
{
ClipChild(canvas);
}
base.DispatchDraw(canvas);
}
protected override void OnDraw(Shape?shape, Canvas?canvas, global::Android.Graphics.Paint?paint)
{
if (paint != null && _backgroundColor != null)
{
paint.Color = _backgroundColor.Value;
}
base.OnDraw(shape, canvas, paint);
}
protected override void OnDraw(Canvas?canvas)
{
base.OnDraw(canvas);
if (canvas is not null && canvasBitmap is not null)
{
canvas.DrawBitmap(canvasBitmap, 0, 0, canvasPaint);
canvas.DrawPath(drawPath, drawPaint);
}
}
void RemoveBackgroundLayer()
{
if (_backgroundLayer == null)
{
return;
}
Children.Remove(_backgroundLayer);
_backgroundLayer = null;
}
public void Init(TriangleObservable thisMod)
{
_thisMod = thisMod;
_cardList = thisMod.CardList;
_cardList.CollectionChanged += CollectionChange;
_thisCanvas = new Canvas();
_thisMod.PositionUI = this;
PopulateCards();
Content = _thisCanvas;
}
private void MoveThumb(Canvas?canvas, Thumb?thumb, double x, double y)
{
if (canvas != null && thumb != null)
{
double left = Clamp(x, 0, canvas.Bounds.Width);
double top = Clamp(y, 0, canvas.Bounds.Height);
Canvas.SetLeft(thumb, left);
Canvas.SetTop(thumb, top);
}
}
public void LoadControls(ClockObservable thisMod)
{
_thisMod = thisMod;
_thisCanvas = new Canvas();
thisMod.PositionUI = this;
Content = _thisCanvas;
if (_thisMod.ClockList != null && _thisMod.ClockList.Count > 0)
{
PrivateReposition();
}
}
protected override void OnDraw(Canvas?canvas)
{
base.OnDraw(canvas);
if (canvas is not null)
{
Draw(Element.Lines, canvas);
canvas.DrawBitmap(canvasBitmap !, 0, 0, canvasPaint);
canvas.DrawPath(drawPath, drawPaint);
}
}
public void EnsureFocusVisualRoot()
{
if (FocusVisualRoot == null)
{
FocusVisualRoot = new Canvas()
{
Background = null,
IsHitTestVisible = false
};
Canvas.SetZIndex(FocusVisualRoot, FocusVisualZIndex);
}
}
protected override void OnDraw(Canvas?canvas)
{
//System.Diagnostics.Debug.WriteLine("[OKYN] AndroidPaintView->OnDraw( " + canvas + ")");
if (canvas == null)
{
return;
}
_renderContext.Canvas = canvas;
_renderContext.DrawMainElement(_view,
_targetRect, _viewState);
}
protected override void OnSizeChanged(int w, int h, int oldw, int oldh)
{
const int minW = 1;
const int minH = 1;
w = w < minW ? minW : w;
h = h < minH ? minH : h;
base.OnSizeChanged(w, h, oldw, oldh);
canvasBitmap = Bitmap.CreateBitmap(w, h, Bitmap.Config.Argb8888 !) !;
drawCanvas = new Canvas(canvasBitmap);
LoadPoints();
}
public Picture EndRecording()
{
var picture = new Picture
{
CullRect = CullRect,
Commands = RecordingCanvas?.Commands
};
CullRect = Rect.Empty;
RecordingCanvas = null;
return(picture);
}
public void OnApplyTemplate()
{
if (TopCanvas != null ||
BottomCanvas != null ||
_scrollBar.Template.FindName("PART_TopCanvas", _scrollBar) is not Canvas topCanvas ||
_scrollBar.Template.FindName("PART_BottomCanvas", _scrollBar) is not Canvas bottomCanvas)
{
return;
}
TopCanvas = topCanvas;
BottomCanvas = bottomCanvas;
_scrollBar.SizeChanged += (_, _) => DrawSegmentBoundaries();
}
/// <inheritdoc />
protected override void OnDraw(Canvas?canvas)
{
if (canvas is null)
{
return;
}
float size = MeasuredWidth > MeasuredHeight ? MeasuredHeight : MeasuredWidth;
var strokeWidth = Compass.CalculateScreenDimension(1.5f, ComplexUnitType.Dip, Context);
float c = size * .5f;
float l = (MeasuredWidth - size) * .5f;
float t = (MeasuredHeight - size) * .5f;
Paint paint = new Paint(PaintFlags.AntiAlias);
paint.SetStyle(Paint.Style.Fill);
paint.SetARGB(255, 51, 51, 51);
canvas.DrawCircle(c + l, c + t, size * .5f, paint);
paint.SetStyle(Paint.Style.Stroke);
paint.StrokeWidth = strokeWidth;
paint.SetARGB(255, 255, 255, 255);
canvas.DrawCircle(c + l, c + t, (size * .5f) - (strokeWidth / 2f), paint);
// Draw north arrow
paint.SetStyle(Paint.Style.Fill);
paint.SetARGB(255, 199, 85, 46);
var path = new Path();
path.MoveTo(c - (size * .14f) + l, c + t);
path.LineTo(c + (size * .14f) + l, c + t);
path.LineTo(c + l, c - (size * .34f) + t);
path.Close();
canvas.DrawPath(path, paint);
// Draw south arrow
paint.SetARGB(255, 255, 255, 255);
path = new Path();
path.MoveTo(c - (size * .14f) + l, c + t);
path.LineTo(c + (size * .14f) + l, c + t);
path.LineTo(c + l, c + (size * .34f) + t);
path.Close();
canvas.DrawPath(path, paint);
PivotX = (size / 2) + l;
PivotY = (size / 2) + t;
base.OnDraw(canvas);
}
/// <summary>
/// Подготавливает дисплей к отрисовке нового содержимого.
/// </summary>
private void Swap()
{
var width = Console.WindowWidth;
var height = Console.WindowHeight;
if (prev != null && prev.Size == (width, height))
{
(CurrentScreen, prev) = (prev, CurrentScreen);
CurrentScreen.Clear();
}
else
{
prev = null;
CurrentScreen = new Canvas(width, height);
}
}
protected override void OnSizeChanged(int w, int h, int oldw, int oldh)
{
const int minW = 1;
const int minH = 1;
w = w < minW ? minW : w;
h = h < minH ? minH : h;
base.OnSizeChanged(w, h, oldw, oldh);
canvasBitmap = Bitmap.CreateBitmap(w, h, Bitmap.Config.Argb8888 ?? throw new NullReferenceException("Unable to create Bitmap config"));
if (canvasBitmap is not null)
{
drawCanvas = new Canvas(canvasBitmap);
LoadLines();
}
}
/// <summary>
/// Executes the draw action.
/// </summary>
///
/// <param name="canvas"> The canvas. </param>
protected override void OnDraw(Canvas?canvas)
{
var frame = (ExtendedFrame)this.Element;
using var firstPaint = new Paint();
using var secondPaint = new Paint();
using var backgroundPaint = new Paint();
firstPaint.AntiAlias = true;
firstPaint.SetStyle(Paint.Style.Stroke);
firstPaint.StrokeWidth = frame.BorderWidth + 2;
firstPaint.Color = frame.BorderColor.ToAndroid();
secondPaint.AntiAlias = true;
secondPaint.SetStyle(Paint.Style.Stroke);
secondPaint.StrokeWidth = frame.BorderWidth;
secondPaint.Color = frame.BackgroundColor.ToAndroid();
backgroundPaint.SetStyle(Paint.Style.Stroke);
backgroundPaint.StrokeWidth = 4;
backgroundPaint.Color = frame.BackgroundColor.ToAndroid();
using Rect oldBounds = new ();
if (canvas != null)
{
canvas.GetClipBounds(oldBounds);
using RectF oldOutlineBounds = new ();
oldOutlineBounds.Set(oldBounds);
using RectF myOutlineBounds = new ();
myOutlineBounds.Set(oldBounds);
myOutlineBounds.Top += (int)secondPaint.StrokeWidth + 3;
myOutlineBounds.Bottom -= (int)secondPaint.StrokeWidth + 3;
myOutlineBounds.Left += (int)secondPaint.StrokeWidth + 3;
myOutlineBounds.Right -= (int)secondPaint.StrokeWidth + 3;
canvas.DrawRoundRect(oldOutlineBounds, 10, 10, backgroundPaint); // to "hide" old outline
canvas.DrawRoundRect(myOutlineBounds, frame.CornerRadius, frame.CornerRadius, firstPaint);
canvas.DrawRoundRect(myOutlineBounds, frame.CornerRadius, frame.CornerRadius, secondPaint);
base.OnDraw(canvas);
}
}
public override void Draw(Canvas?canvas)
{
try
{
if (canvas != null)
{
canvas.ClipRect(canvas.ClipBounds);
}
base.Draw(canvas);
}
catch (Java.Lang.NullPointerException)
{
// This will most likely never run since UpdateScrollBars is called
// when the scrollbars visibilities are updated but I left it here
// just in case there's an edge case that causes an exception
this.HandleScrollBarVisibilityChange();
}
}
protected override void OnDraw(Canvas?canvas)
{
base.OnDraw(canvas);
foreach (var line in Element.Lines)
{
var path = new Path();
path.MoveTo((float)line.Points[0].X, (float)line.Points[0].Y);
foreach (var(x, y) in line.Points)
{
path.LineTo((float)x, (float)y);
}
canvas?.DrawPath(path, drawPaint);
}
canvas?.DrawBitmap(canvasBitmap !, 0, 0, canvasPaint);
canvas?.DrawPath(drawPath, drawPaint);
}
protected override void DispatchDraw(Canvas?canvas)
{
if (canvas != null && Clip != null)
{
var bounds = new RectangleF(0, 0, canvas.Width, canvas.Height);
if (_lastPathSize != bounds.Size || _currentPath == null)
{
var path = Clip.PathForBounds(bounds);
_currentPath = path?.AsAndroidPath();
_lastPathSize = bounds.Size;
}
if (_currentPath != null)
{
canvas.ClipPath(_currentPath);
}
}
base.DispatchDraw(canvas);
}
void AddBackgroundLayer()
{
// In WinUI, once a control has hit testing disabled, all of its child controls
// also have hit testing disabled. The exception is a Panel with its
// Background Brush set to `null`; the Panel will be invisible to hit testing, but its
// children will work just fine.
// In order to handle the situation where we need the layout to be invisible to hit testing,
// the child controls to be visible to hit testing, *and* we need to support non-null
// background brushes, we insert another empty Panel which is invisible to hit testing; that
// Panel will be our Background brush
if (_backgroundLayer != null)
{
return;
}
_backgroundLayer = new Canvas {
IsHitTestVisible = false
};
Children.Insert(0, _backgroundLayer);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Removes the drop shadow. </summary>
////////////////////////////////////////////////////////////////////////////////////////////////////
internal void RemoveDropShadow()
{
//Remove the elements that we added to the _parent.Children
try
{
if (_parent == null)
{
return;
}
//Hiding the shadow will take care of a few steps needed to completely remove
// the shadow.
HideDropShadow();
var childCollection = _parent.Children;
if (childCollection.Contains(_roundedRectMask))
{
childCollection.Remove(_roundedRectMask);
}
if (childCollection.Contains(_dropShadowHost))
{
childCollection.Remove(_dropShadowHost);
}
_roundedRectMask = null;
_dropShadowHost = null;
_elementsOriginalMargin = null;
}
//I would not want cleanup work to cause an exception. There is nothing we need to do, but
// we developers need to know if it is happening during development.
catch (Exception e)
{
Debug.WriteLine($"{nameof(RemoveDropShadow)} caused the following exception : {e}");
}
}
protected override void OnTemplateApplied(TemplateAppliedEventArgs e)
{
if (_colorCanvas != null)
{
_colorCanvas.PointerPressed -= ColorCanvas_PointerPressed;
_colorCanvas.PointerReleased -= ColorCanvas_PointerReleased;
_colorCanvas.PointerMoved -= ColorCanvas_PointerMoved;
}
if (_colorThumb != null)
{
_colorThumb.DragDelta -= ColorThumb_DragDelta;
}
if (_hueCanvas != null)
{
_hueCanvas.PointerPressed -= HueCanvas_PointerPressed;
_hueCanvas.PointerReleased -= HueCanvas_PointerReleased;
_hueCanvas.PointerMoved -= HueCanvas_PointerMoved;
}
if (_hueThumb != null)
{
_hueThumb.DragDelta -= HueThumb_DragDelta;
}
if (_alphaCanvas != null)
{
_alphaCanvas.PointerPressed -= AlphaCanvas_PointerPressed;
_alphaCanvas.PointerReleased -= AlphaCanvas_PointerReleased;
_alphaCanvas.PointerMoved -= AlphaCanvas_PointerMoved;
}
if (_alphaThumb != null)
{
_alphaThumb.DragDelta -= AlphaThumb_DragDelta;
}
_colorCanvas = e.NameScope.Find <Canvas>("PART_ColorCanvas");
_colorThumb = e.NameScope.Find <Thumb>("PART_ColorThumb");
_hueCanvas = e.NameScope.Find <Canvas>("PART_HueCanvas");
_hueThumb = e.NameScope.Find <Thumb>("PART_HueThumb");
_alphaCanvas = e.NameScope.Find <Canvas>("PART_AlphaCanvas");
_alphaThumb = e.NameScope.Find <Thumb>("PART_AlphaThumb");
if (_colorCanvas != null)
{
_colorCanvas.PointerPressed += ColorCanvas_PointerPressed;
_colorCanvas.PointerReleased += ColorCanvas_PointerReleased;
_colorCanvas.PointerMoved += ColorCanvas_PointerMoved;
}
if (_colorThumb != null)
{
_colorThumb.DragDelta += ColorThumb_DragDelta;
}
if (_hueCanvas != null)
{
_hueCanvas.PointerPressed += HueCanvas_PointerPressed;
_hueCanvas.PointerReleased += HueCanvas_PointerReleased;
_hueCanvas.PointerMoved += HueCanvas_PointerMoved;
}
if (_hueThumb != null)
{
_hueThumb.DragDelta += HueThumb_DragDelta;
}
if (_alphaCanvas != null)
{
_alphaCanvas.PointerPressed += AlphaCanvas_PointerPressed;
_alphaCanvas.PointerReleased += AlphaCanvas_PointerReleased;
_alphaCanvas.PointerMoved += AlphaCanvas_PointerMoved;
}
if (_alphaThumb != null)
{
_alphaThumb.DragDelta += AlphaThumb_DragDelta;
}
}
protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
{
if (colorCanvas != null)
{
colorCanvas.PointerPressed -= ColorCanvas_PointerPressed;
colorCanvas.PointerReleased -= ColorCanvas_PointerReleased;
colorCanvas.PointerMoved -= ColorCanvas_PointerMoved;
}
if (colorThumb != null)
{
colorThumb.DragDelta -= ColorThumb_DragDelta;
}
if (hueCanvas != null)
{
hueCanvas.PointerPressed -= HueCanvas_PointerPressed;
hueCanvas.PointerReleased -= HueCanvas_PointerReleased;
hueCanvas.PointerMoved -= HueCanvas_PointerMoved;
}
if (hueThumb != null)
{
hueThumb.DragDelta -= HueThumb_DragDelta;
}
if (alphaCanvas != null)
{
alphaCanvas.PointerPressed -= AlphaCanvas_PointerPressed;
alphaCanvas.PointerReleased -= AlphaCanvas_PointerReleased;
alphaCanvas.PointerMoved -= AlphaCanvas_PointerMoved;
}
if (alphaThumb != null)
{
alphaThumb.DragDelta -= AlphaThumb_DragDelta;
}
colorCanvas = e.NameScope.Find <Canvas>("PART_ColorCanvas");
colorThumb = e.NameScope.Find <Thumb>("PART_ColorThumb");
hueCanvas = e.NameScope.Find <Canvas>("PART_HueCanvas");
hueThumb = e.NameScope.Find <Thumb>("PART_HueThumb");
alphaCanvas = e.NameScope.Find <Canvas>("PART_AlphaCanvas");
alphaThumb = e.NameScope.Find <Thumb>("PART_AlphaThumb");
if (colorCanvas != null)
{
colorCanvas.PointerPressed += ColorCanvas_PointerPressed;
colorCanvas.PointerReleased += ColorCanvas_PointerReleased;
colorCanvas.PointerMoved += ColorCanvas_PointerMoved;
}
if (colorThumb != null)
{
colorThumb.DragDelta += ColorThumb_DragDelta;
}
if (hueCanvas != null)
{
hueCanvas.PointerPressed += HueCanvas_PointerPressed;
hueCanvas.PointerReleased += HueCanvas_PointerReleased;
hueCanvas.PointerMoved += HueCanvas_PointerMoved;
}
if (hueThumb != null)
{
hueThumb.DragDelta += HueThumb_DragDelta;
}
if (alphaCanvas != null)
{
alphaCanvas.PointerPressed += AlphaCanvas_PointerPressed;
alphaCanvas.PointerReleased += AlphaCanvas_PointerReleased;
alphaCanvas.PointerMoved += AlphaCanvas_PointerMoved;
}
if (alphaThumb != null)
{
alphaThumb.DragDelta += AlphaThumb_DragDelta;
}
}
protected override void OnDraw(Shape?shape, Canvas?canvas, APaint?paint)
{
if (_disposed)
{
return;
}
if (HasBorder())
{
if (Paint != null)
{
SetBackground(Paint);
}
if (_borderPaint != null)
{
_borderPaint.StrokeWidth = _strokeThickness;
_borderPaint.StrokeJoin = _strokeLineJoin;
_borderPaint.StrokeCap = _strokeLineCap;
_borderPaint.StrokeMiter = _strokeMiterLimit * 2;
if (_borderPathEffect != null)
{
_borderPaint.SetPathEffect(_borderPathEffect);
}
if (_borderColor != null)
{
_borderPaint.Color = _borderColor.Value;
}
else
{
if (_stroke != null)
{
SetPaint(_borderPaint, _stroke);
}
}
}
if (_invalidatePath)
{
_invalidatePath = false;
if (_shape != null)
{
var bounds = new Graphics.Rect(0, 0, _width, _height);
var path = _shape.PathForBounds(bounds);
var clipPath = path?.AsAndroidPath();
if (clipPath == null)
{
return;
}
if (_clipPath != null)
{
_clipPath.Reset();
_clipPath.Set(clipPath);
}
}
}
if (canvas == null)
{
return;
}
var saveCount = canvas.SaveLayer(0, 0, _width, _height, null);
if (_clipPath != null && Paint != null)
{
canvas.DrawPath(_clipPath, Paint);
}
if (_clipPath != null && _borderPaint != null)
{
canvas.DrawPath(_clipPath, _borderPaint);
}
canvas.RestoreToCount(saveCount);
}
else
{
if (paint != null)
{
SetBackground(paint);
}
base.OnDraw(shape, canvas, paint);
}
}