public void MouseUpHandler(object sender, MouseEventArgs e)
{
if (e.LeftButton == MouseButtonState.Released)
{
if (rectW != 0 && rectH != 0 && currentPoint.X != 0 && currentPoint.Y != 0)
{
if (rectW < 0)
{
currentPoint.X = currentPoint.X + rectW;
rectW = -rectW;
}
if (rectH < 0)
{
currentPoint.Y = currentPoint.Y + rectH;
rectH = -rectH;
}
RemoveTempMarker();
MainWindow mv = Application.Current.Windows.OfType <MainWindow>().FirstOrDefault();
tmpRect = DrawCanvas.Rect(currentPoint.X, currentPoint.Y, (int)rectW, (int)rectH, Brushes.Red, mv.CanvasResult, 0.3);
currentPoint = default(Point);
rectW = 0;
rectH = 0;
}
}
}
private void AddBranch(FractalLine parent, int Depth)
{
if (Depth > SplitDepth || Draw == false)
{
return;
}
double Angle1 = parent.m_Angle - AngleDelta;
double Angle2 = parent.m_Angle + AngleDelta;
FractalLine line = new FractalLine(parent.m_End, (int)(parent.CalcLength() * ShrinkRate), Angle1, parent);
FractalLine line2 = new FractalLine(parent.m_End, (int)(parent.CalcLength() * ShrinkRate), Angle2, parent);
System.Threading.Thread.Sleep(Int32.Parse(txtAnimDelay.Text));
//UI commands must be invoked on ui thread
Action a = () => DrawCanvas.Refresh();
InvokeUI(a);
/*Take turns on which side goes first,
* This prevents one side of the tree from completing first*/
if (Depth % 2 == 0)
{
AddBranch(line, Depth + 1);
AddBranch(line2, Depth + 1);
}
else
{
AddBranch(line2, Depth + 1);
AddBranch(line, Depth + 1);
}
}
public void drawScroller(DrawCanvas canvas, Rect drawRegion, Rect contentsSize)
{
this.drawRegion = drawRegion;
this.contentsSize = contentsSize;
if (hideBars)
{
return;
}
if (yScrollEnabled())
{
ICanvasRectItem rectangle = new CanvasItemFactory().createCanvasRectItem();
rectangle.setColor(new Layout.Color(scrollerBrightness, scrollerBrightness, scrollerBrightness));
rectangle.setSize(scrollerWidth, scrollerHeight);
canvas.drawToCanvas(rectangle, drawRegion.Right - scrollerWidth - scrollerPadding, drawRegion.Top + scrollerPadding + getYScrollerYPos());
}
if (drawRegion.Width < contentsSize.Width)
{
ICanvasRectItem rectangle = new CanvasItemFactory().createCanvasRectItem();
rectangle.setColor(new Layout.Color(scrollerBrightness, scrollerBrightness, scrollerBrightness));
rectangle.setSize(scrollerHeight, scrollerWidth);
canvas.drawToCanvas(rectangle, drawRegion.Left + scrollerPadding + getXScrollerXPos(), drawRegion.Bottom - scrollerWidth - scrollerPadding);
}
}
public override void _Ready()
{
var canvas = new DrawCanvas((pen) =>
{
// Stop when theta > MaxTheta
if (theta < MaxTheta)
{
for (int i = 0; i < Iterations; ++i)
{
float x = (Width + margin) * Mathf.Cos(theta);
float y = (Width + margin) * Mathf.Sin(theta);
var target = new Vector2(x, y);
var size = GetViewportRect().Size;
pen.DrawCircle((size / 2) + target, Width / 2, MathUtils.RandColor());
theta += 0.016f;
margin += 0.016f * 3;
}
}
});
canvas.QueueClearDrawing(Color.Color8(45, 45, 45));
AddChild(canvas);
}
public override void _Ready()
{
generator = new RandomNumberGenerator();
generator.Randomize();
var canvas = new DrawCanvas((pen) =>
{
var size = GetViewportRect().Size;
// Follow mouse for fun
var mousePosition = GetViewport().GetMousePosition();
float xNum = generator.Randfn(0, 1); // Gaussian distribution
float yNum = generator.Randfn(0, 1); // Gaussian distribution
var colNumR = (byte)(generator.Randfn(0, 1) * 255);
var colNumG = (byte)(generator.Randfn(0, 1) * 255);
var colNumB = (byte)(generator.Randfn(0, 1) * 255);
float x = (20 * xNum) + mousePosition.x;
float y = (20 * yNum) + mousePosition.y;
pen.DrawCircle(new Vector2(x, y), 8, Color.Color8(colNumR, colNumG, colNumB, 64));
});
canvas.QueueClearDrawing(Color.Color8(45, 45, 45));
AddChild(canvas);
}
private void OnSizeChanged(object sender, SizeChangedEventArgs e)
{
var width = e.NewSize.Width;
var height = e.NewSize.Height;
_startPoint = new Vector2((float)width / 2f, (float)height / 2f);
DrawCanvas.Invalidate();
}
/// <summary>
/// Activates the DrawCanvas event
/// </summary>
/// <param name="g">Graphics2D attached to the inactive buffer</param>
public void OnDrawCanvas(Graphics g)
{
int msec = Uwu.Core.Runtime.Milliseconds;
float dt = (msec - LastUpdateMsec) / 1000f;
DrawCanvas?.Invoke(this, g, dt);
LastUpdateMsec = msec;
}
private void OnPointerPressed(object sender, PointerRoutedEventArgs e)
{
_isDragging = true;
_startPoint = e.GetCurrentPoint(DrawCanvas).Position.ToVector2();
_endPoint = _startPoint;
_colorIndex = (_colorIndex + 1) % _colors.Length;
_splineColor = _colors[_colorIndex];
DrawCanvas.Invalidate();
}
private void OnPointerMoved(object sender, PointerRoutedEventArgs e)
{
if (!_isDragging)
{
return;
}
_drawSpline = true;
_endPoint = e.GetCurrentPoint(DrawCanvas).Position.ToVector2();
DrawCanvas.Invalidate();
}
public MainWindow() : base("Canvas Test")
{
canvas = new DrawCanvas();
Add(canvas);
/* Calls RedrawCanvas() every 15 ms */
GLib.Timeout.Add(15, new GLib.TimeoutHandler(RedrawCanvas));
/* Show all widgets (recursively) */
ShowAll();
}
private void drawTree(MeasuredLayout item, DrawCanvas canvas)
{
foreach (MeasuredLayout child in item.getCalculatedChildren())
{
DrawCanvas canvasClone = canvas.Clone();
canvasClone.setTopLeft(item.getBounds().rect.Left, item.getBounds().rect.Top);
child.drawable.draw(canvasClone, child.getBounds().rect);
drawTree(child, canvasClone);
}
}
public void MouseMoveHandler(object sender, MouseEventArgs e)
{
if (e.LeftButton == MouseButtonState.Pressed)
{
System.Windows.Point pos = e.GetPosition((Canvas)sender);
MainWindow mv = Application.Current.Windows.OfType <MainWindow>().FirstOrDefault();
Line line = DrawCanvas.NewLine(currentPoint.X, currentPoint.Y, pos.X, pos.Y, ForegroundLineMarker, mv.CanvasDraw);
currentPoint = pos;
LineMarkers.Add(line);
}
}
public DrawCanvas Clone()
{
DrawCanvas newCanvas = new DrawCanvas(canvas);
newCanvas.startX = startX;
newCanvas.startY = startY;
newCanvas.clipingBounds = clipingBounds;
newCanvas.clippingEnbaled = clippingEnbaled;
return(newCanvas);
}
/// <summary>
/// Save Artboard Tuple
/// </summary>
/// <param name="_canvas"></param>
/// <param name="_fileName"></param>
/// <returns></returns>
public (string FileName, FileInfo FileInfo) SaveArtBoard(DrawCanvas _canvas, string _fileName)
{
//Create the FileInfo
var info = new FileInfo(_fileName);
//Save the InkStrokes
SaveInkStrokes(_canvas, _fileName);
return(_fileName, info);
}
public override void _Ready()
{
walker = new Walker();
walker.SetXY(GetViewportRect().Size / 2);
AddChild(walker);
var canvas = new DrawCanvas((pen) => pen.DrawRect(walker.GetStepRect(), Colors.LightCyan, true));
canvas.QueueClearDrawing(Color.Color8(45, 45, 45));
AddChild(canvas);
}
/// <summary>
/// Load ArtBoard Tuple
/// </summary>
/// <param name="_fileName"></param>
/// <param name="_canvas"></param>
/// <returns></returns>
public (string FileName, FileInfo FileInfo) LoadArtBoard(string _fileName, DrawCanvas _canvas)
{
var info = new FileInfo(_fileName);
_canvas.Strokes.Clear();
LoadInkStrokes(_canvas, _fileName);
_canvas.Select(_canvas.Strokes);
return(_fileName, info);
}
public override void draw(DrawCanvas drawCanvas, Rect rect)
{
drawCanvas.enableClipping((int)rect.Left, (int)rect.Top, (int)rect.Width, (int)rect.Height);
ICanvasTextItem textCanvasItem = new CanvasItemFactory().createCanvasTextItem();
textCanvasItem.setText(text);
textCanvasItem.setTextColor(textColor);
textCanvasItem.setTextSize(textSize);
drawCanvas.drawToCanvas(textCanvasItem, rect.Left, rect.Top);
drawCanvas.disableClipping();
}
private void Save_Click(object sender, RoutedEventArgs e)
{
using (var img = DrawCanvas.Crop())
{
if (img != null)
{
var p = AddSuffix(state.Filename, "_" + state.Counter);
img.ImWrite(p);
state.Counter += 1;
DrawCanvas.Reset();
}
}
}
private void BtnDraw_Click(object sender, EventArgs e)
{
Draw = true;
UpdateParameters();
//Run in new thread to keep UI responsive
Task.Run(() =>
{
int MiddleCanvasX = DrawCanvas.Size.Width / 2;
Trunk = new FractalLine(new Point(MiddleCanvasX, DrawCanvas.Size.Height), StartHeight, 90, null);
AddBranch(Trunk, 0);
DrawCanvas.Invalidate();
});
}
private void drawCursor(DrawCanvas drawCanvas, Rect bounds, double charWidth, double charHeight)
{
Point cursorPos = getTextPosForIndex(getCursorIndex());
cursorPos.X += bounds.Left; // Add textBox offset
cursorPos.Y += bounds.Top;
cursorPos.X += scroller.scrollX; // Add textBox offset
cursorPos.Y += scroller.scrollY;
ICanvasRectItem cursorRect = new CanvasItemFactory().createCanvasRectItem();
cursorRect.setColor(edgeColor);
cursorRect.setSize(CURSOR_WIDTH, charHeight - 2);
drawCanvas.drawToCanvas(cursorRect, cursorPos.X + 1, cursorPos.Y + 1);
}
private void CaptureCanvasBtn_Clicked(object sender, RoutedEventArgs e)
{
var png = DrawCanvas.ToBitmap().ToPng();
var saveFileDialog = new SaveFileDialog();
saveFileDialog.FileName = DateTime.Now.ToString("yyyy_MM_dd_HHmmss");
saveFileDialog.Filter = "Png File (*.png) | *.png";
if (saveFileDialog.ShowDialog() == true)
{
using (Stream fileStream = File.Create(saveFileDialog.FileName))
{
png.Save(fileStream);
}
}
}
// Test for activing the continue Button and move to next scene
public IEnumerator testClickButtonToNextScene()
{
// panel = GameObject.Find ("Panel");
// buttonContinue = panel.transform.Find ("ButtonContinue").gameObject;
// buttonContinue.SetActive (true);
// buttonContinue.GetComponent<Button> ().onClick.Invoke();
DrawCanvas drawCanvas = GameObject.Find("Cover").GetComponent <DrawCanvas> ();
drawCanvas.Invoke("NextScene", 0);
yield return(null);
Scene currentScene = SceneManager.GetActiveScene();
Assert.AreEqual("14-cutscene", currentScene.name);
yield return(null);
}
public override void _Ready()
{
generator = new RandomNumberGenerator();
generator.Randomize();
var canvas = new DrawCanvas((pen) =>
{
var size = GetViewportRect().Size;
float num = generator.Randfn(0, 1); // Gaussian distribution
float sd = size.x / 8;
float mean = size.x / 2;
float x = (sd * num) + mean;
pen.DrawCircle(new Vector2(x, size.y / 2), 8, Colors.LightCyan.WithAlpha(10));
});
canvas.QueueClearDrawing(Color.Color8(45, 45, 45));
AddChild(canvas);
}
void AddMask()
{
if (tmpRect.ActualWidth != 0 && tmpRect.ActualHeight != 0)
{
RectMarkers.Add(tmpRect);
MainWindow mv = Application.Current.Windows.OfType <MainWindow>().FirstOrDefault();
double x = Canvas.GetLeft(tmpRect);
double y = Canvas.GetTop(tmpRect);
tmpText = DrawCanvas.Text(x, y, (TextMarkers.Count + 1).ToString(), true, Brushes.Yellow, mv.CanvasResult, false);
TextMarkers.Add(tmpText);
tmpRect = new Rectangle();
tmpText = new TextBlock();
OnPropertyChanged("MaskCounts");
}
}
private void drawCharecterHighlight(DrawCanvas canvas, char charecter, double x, double y, Color color)
{
if (color.a == 0)
{
return;
}
double selectionWidth = charecterDimensions.Width;
if (charecter == '\t')
{
selectionWidth *= tabSpaces;
}
ICanvasRectItem selection = new CanvasItemFactory().createCanvasRectItem();
selection.setColor(color);
selection.setSize(selectionWidth, charecterDimensions.Height);
canvas.drawToCanvas(selection, x, y);
}
// Test for drawing on the canvas and update percentage
public IEnumerator testDrawOnTheCanvas()
{
DrawCanvas drawCanvas = GameObject.Find("Cover").GetComponent <DrawCanvas> ();
Assert.AreNotEqual("Scan Complete!", drawCanvas.textPercent.text);
for (float i = -2.3f; i < 1.4f; i += 0.4f)
{
for (float j = 1.6f; j > -2f; j -= 0.4f)
{
drawCanvas.BrushPlace(new Vector2(i, j));
yield return(new WaitForSecondsRealtime(0.05f));
drawCanvas.Invoke("UpdatePercent", 0);
}
}
Assert.AreEqual("Scan Complete!", drawCanvas.textPercent.text); // When game is completed, textPercentage shows "Scan Complete!"
yield return(null);
}
private void pictureBox1_Click(object sender, EventArgs e)
{
Graphics gr = DrawCanvas.CreateGraphics();
double x, y, prevX = 0, prevY = 0;
float a = 13, b = 7;
float offsetX = DrawCanvas.Size.Width / 2;
float offsetY = DrawCanvas
float angleStep = 0.5f;
for (float angle = 0; angle < 360; angle += angleStep)
{
x = (a + b) * Math.Cos(angle) - a * Math.Cos((a + b) * angle / a);
y = (a + b) * Math.Sin(angle) - a * Math.Sin((a + b) * angle / a);
if (angle > 0)
{
gr.DrawLine(new Pen(Color.Black), (float)prevX, (float)prevY, (float)x, (float)y);
}
prevX = x;
prevY = y;
}
}
public static void Test()
{
DrawCanvas canvas = new DrawCanvas();
while (true)
{
canvas.Paint();
Console.ReadKey();
Random r = new Random();
if (r.Next(10) >= 5)
{
canvas.Undo();
}
else
{
canvas.Draw(r.Next(10), r.Next(10));
}
}
}
/// <summary>
/// Constructor which sets Event Handlers and design elements
/// </summary>
public EditPage()
{
this.InitializeComponent();
DrawCanvas.PointerEntered += (sender, e) =>
{
Window.Current.CoreWindow.PointerCursor =
new Windows.UI.Core.CoreCursor(Windows.UI.Core.CoreCursorType.Cross, 1);
};
DrawCanvas.PointerExited += (sender, e) =>
{
Window.Current.CoreWindow.PointerCursor =
new Windows.UI.Core.CoreCursor(Windows.UI.Core.CoreCursorType.Arrow, 1);
};
ClassCanvas.Fill = new SolidColorBrush(Colors.Wheat);
DrawCanvas.Fill = new SolidColorBrush(Colors.DarkGray);
this.Loaded += (sender, e) => { ToolState = new CreateClassState(); };
IsDrawingBoardOpen = true;
DrawCanvas.AddDrawingBoard();
_instance = this;
}
public override void draw(DrawCanvas drawCanvas, Rect rect)
{
ICanvasRectItem edge = new CanvasItemFactory().createCanvasRectItem();
edge.setColor(edgeColor);
edge.setSize(rect.Width, rect.Height);
drawCanvas.drawToCanvas(edge, rect.Left, rect.Top);
if (rect.Width - 2 * BORDER_SIZE < 0 || rect.Height - 2 * BORDER_SIZE < 0)
{
return;
}
Rect textRegion = new Rect(new Point(rect.Left + BORDER_SIZE, rect.Top + BORDER_SIZE), new Size(rect.Width - 2 * BORDER_SIZE, rect.Height - 2 * BORDER_SIZE));
drawCanvas.enableClipping((int)textRegion.Left, (int)textRegion.Top, (int)textRegion.Width, (int)textRegion.Height);
ICanvasRectItem background = new CanvasItemFactory().createCanvasRectItem();
background.setColor(backgroundColor);
background.setSize(textRegion.Width, textRegion.Height);
drawCanvas.drawToCanvas(background, textRegion.X, textRegion.Y);
calcualteAllTextPositions();
previousBounds = new Rect(new Point(textRegion.X, textRegion.Y), new Size(textRegion.Width, textRegion.Height));
int selectionStartIndex = Math.Min(selectionBeganIndex, cursorIndex);
int selectionEndIndex = Math.Max(selectionBeganIndex, cursorIndex);
for (int i = 0; i < displayText.Length; i++)
{
if (displayText[i] == '\r' || displayText[i] == '\n')
{
continue;
}
Point letterPos = getTextPosForIndex(i);
letterPos.X += textRegion.Left; // Add textBox offset
letterPos.Y += textRegion.Top;
letterPos.X += scroller.scrollX; // Add textBox offset
letterPos.Y += scroller.scrollY;
if (letterPos.X + charecterDimensions.Width < 0)
{
continue;
}
if (letterPos.Y + charecterDimensions.Height < 0)
{
continue;
}
if (letterPos.X > textRegion.Width)
{
continue;
}
if (letterPos.Y > textRegion.Height + rect.Top)
{
continue;
}
if ((i >= selectionStartIndex && i < selectionEndIndex)) // Draw cursor selection
{
drawCharecterHighlight(drawCanvas, displayText[i], letterPos.X, letterPos.Y, edgeColor);
}
else
{
drawCharecterHighlight(drawCanvas, displayText[i], letterPos.X, letterPos.Y, contents.getColorForCharAtIndex(i));
}
if (displayText[i] != '\t')
{
ICanvasTextItem letterCanvasItem = new CanvasItemFactory().createCanvasTextItem();
letterCanvasItem.setText(displayText[i] + "");
drawCanvas.drawToCanvas(letterCanvasItem, letterPos.X, letterPos.Y);
}
}
if (singleLine)
{
scroller.hideBars = true;
}
scroller.drawScroller(drawCanvas, textRegion, new Rect(new Size(maxXPos + charecterDimensions.Width, maxYPos + charecterDimensions.Height)));
drawCanvas.disableClipping();
}
