0% found this document useful (0 votes)
26 views15 pages

5.3C - Drawing Program - Saving and Loading

COS20007 C#OOP

Uploaded by

brian
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
26 views15 pages

5.3C - Drawing Program - Saving and Loading

COS20007 C#OOP

Uploaded by

brian
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 15

5.

3C - Drawing Program - Saving and Loading

Program source code


Drawing.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MyGame;
using SplashKitSDK;

namespace Shapedrawerr
{

public class Drawing


{
private readonly List<Shape> _shapes;
private Color _background;
StreamWriter writer;
StreamReader reader;

public Drawing(Color background)


{
_shapes = new List<Shape>();
_background = background;
}

public Drawing() : this(Color.White)


{

public List<Shape> SelectedShapes()


{
List<Shape> _selectedShapes = new List<Shape>();
foreach (Shape s in _selectedShapes)
{
if (s.Selected)
{
_selectedShapes.Add(s);
}
}
return _selectedShapes;
}

public int ShapeCount


{
get
{
return _shapes.Count;
}
}

public Color Background


{
get
{
return _background;
}
set
{
5.3C - Drawing Program - Saving and Loading

_background = value;
}
}

public void Draw()


{
SplashKit.ClearScreen(_background);

foreach (Shape s in _shapes)


{
s.Draw();
}
}

//Start
//This is an additional function to keep the color of the shape changing
//Like the previous part
public void ChangingShapeColor()
{
foreach (Shape s in _shapes)
{
if (s.Selected)
{
s.COLOR = Color.RandomRGB(255);
}
}
}
//End

public void SelectedShapeAt(Point2D pt)


{
foreach (Shape s in _shapes)
{
if (s.IsAt(pt))
{
s.Selected = true;
}
else
{
s.Selected = false;
}
}
}

public void AddShape(Shape s)


{
_shapes.Add(s);
}

public void RemoveShape()


{
foreach (Shape s in _shapes.ToList())
{
if (s.Selected)
{
_shapes.Remove(s);
}

}
}
//save n load
public void Save(string filename)
{
5.3C - Drawing Program - Saving and Loading

writer = new StreamWriter(filename);


writer.WriteColor(_background);
writer.WriteLine(ShapeCount);

foreach (Shape s in _shapes)


{
s.SaveTo(writer);
}
writer.Close();
}

public void Load(string filename)


{
reader = new StreamReader(filename);
Shape s;
string kind;
Background = reader.ReadColor();
int count = reader.ReadInteger();
_shapes.Clear();

for (int i = 0; i < count; i++)


{
kind = reader.ReadLine();
switch (kind)
{
case "Rectangle":
s = new MyRectangle();
break;
case "Circle":
s = new MyCircle();
break;
case "Line":
s = new MyLine();
break;
default:
throw new InvalidDataException("Error at shape: " +
kind);
}
s.LoadFrom(reader);
AddShape(s);
}
reader.Close();
}

}
}
5.3C - Drawing Program - Saving and Loading

ExtensionMethod.cs
using System;
using System.IO;
using SplashKitSDK;
namespace MyGame
{
public static class ExtensionMethods
{
public static int ReadInteger(this StreamReader reader)
{
return Convert.ToInt32(reader.ReadLine ());
}
public static float ReadSingle(this StreamReader reader)
{
return Convert.ToSingle(reader.ReadLine ());
}
public static Color ReadColor(this StreamReader reader)
{
return Color.RGBColor(reader.ReadSingle(), reader.ReadSingle(),
reader.ReadSingle());
}
public static void WriteColor(this StreamWriter writter, Color clr)
{
writter.WriteLine("{0}\n{1}\n{2}", clr.R, clr.G, clr.B);
}
}
}

MyCircle.cs
using MyGame;
using SplashKitSDK;
using System;
using System.Collections.Generic;

using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Shapedrawerr
{

public class MyCircle : Shape


{
private int _radius;

public MyCircle(Color clr, int radius) : base(clr)


{
_radius = radius;
}

public MyCircle() : this(Color.RandomRGB(255), 50) { }

public override void Draw()


{
if (Selected)
{
DrawOutline();
5.3C - Drawing Program - Saving and Loading

}
SplashKit.FillCircle(COLOR, X, Y, _radius);
}

public int Radius


{
get
{
return _radius;
}
set
{
_radius = value;
}
}

public override void DrawOutline()


{
SplashKit.FillCircle(Color.Black, X, Y, _radius + 4);
}

public override bool IsAt(Point2D pt)


{
//c^2 = a^2 + b^2
//c = square root(a^2 + b^2)
double a = (double)(pt.X - X);
double b = (double)(pt.Y - Y);
if (Math.Sqrt(a * a + b * b) < _radius)
{
return true;
}
return false;
}
//save n load
public override void SaveTo(StreamWriter writer)
{
writer.WriteLine("Circle");
base.SaveTo(writer);
writer.WriteLine(Radius);
}

public override void LoadFrom(StreamReader reader)


{
base.LoadFrom(reader);
Radius = reader.ReadInteger();
}

}
}

Myline.cs
using MyGame;
using SplashKitSDK;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Shapedrawerr
5.3C - Drawing Program - Saving and Loading

{
public class MyLine : Shape
{
private int _length;

public MyLine(Color clr, int length) : base(clr)


{
_length = length;
}

public MyLine() : this(Color.RandomRGB(255), 100) { }

public override void Draw()


{
if (Selected)
{
DrawOutline();
}
SplashKit.DrawLine(COLOR, X, Y, X + _length, Y);
}

public int Length


{
get => _length;
set => _length = value;
}

public override void DrawOutline()


{
SplashKit.DrawRectangle(Color.Black, X - 2, Y - 2, _length + 5, 5);

public override bool IsAt(Point2D p)


{
return SplashKit.PointOnLine(p, SplashKit.LineFrom(X, Y, X + _length,
Y));
}
public override void SaveTo(StreamWriter writer)
{
writer.WriteLine("Line");
base.SaveTo(writer);
writer.WriteLine(Length);
}

public override void LoadFrom(StreamReader reader)


{
base.LoadFrom(reader);
Length = reader.ReadInteger();
}
}

}
5.3C - Drawing Program - Saving and Loading

MyRectangle.cs
using System;
using System.Collections.Generic;

using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MyGame;
using SplashKitSDK;

namespace Shapedrawerr
{
public class MyRectangle : Shape
{
private int _width, _height;

public MyRectangle(Color clr, float x, float y, int width, int height) :


base(clr)
{
X = x;
Y = y;
Width = width;
Height = height;
}

public MyRectangle() : this(Color.RandomRGB(255), 0, 0, 100, 100) { }

public int Width


{
get
{
return _width;
}
set
{
_width = value;
}
}

public int Height


{
get
{
return _height;
}
set
{
_height = value;
}
}

public override void Draw()


{
if (Selected)
{
DrawOutline();
}
SplashKit.FillRectangle(COLOR, X, Y, Width, Height);
5.3C - Drawing Program - Saving and Loading

public override void DrawOutline()


{
SplashKit.FillRectangle(Color.Black, X - 2, Y - 2, _width + 4,
_height + 4);
}

public override bool IsAt(Point2D p)


{
return SplashKit.PointInRectangle(p, SplashKit.RectangleFrom(X, Y,
Width, Height));
}
public override void SaveTo(StreamWriter writer)
{
writer.WriteLine("Rectangle");
base.SaveTo(writer);
writer.WriteLine(Width);
writer.WriteLine(Height);
}

public override void LoadFrom(StreamReader reader)


{
base.LoadFrom(reader);
Width = reader.ReadInteger();
Height = reader.ReadInteger();
}

}
}
5.3C - Drawing Program - Saving and Loading

Program.cs

using System;
using SplashKitSDK;

namespace Shapedrawerr

{
public class Program
{
private enum ShapeKind
{
Rectangle,
Circle,
Line
}
public static void Main()
{

Drawing drawShape = new Drawing();


ShapeKind kindToAdd = ShapeKind.Rectangle;

new Window("Drawing Shape", 800, 600);


do
{
SplashKit.ProcessEvents();
SplashKit.ClearScreen();

if (SplashKit.KeyTyped(KeyCode.RKey))
{
kindToAdd = ShapeKind.Rectangle;
}
if (SplashKit.KeyTyped(KeyCode.LKey))
{
kindToAdd = ShapeKind.Line;
}
if (SplashKit.KeyTyped(KeyCode.CKey))
{
kindToAdd = ShapeKind.Circle;
}

//Start
//Use this to draw shape
if (SplashKit.MouseClicked(MouseButton.LeftButton))
{
if (kindToAdd == ShapeKind.Rectangle)
{
MyRectangle ShapeDrawn = new MyRectangle();
ShapeDrawn.X = SplashKit.MouseX();
ShapeDrawn.Y = SplashKit.MouseY();
drawShape.AddShape(ShapeDrawn);

}
if (kindToAdd == ShapeKind.Circle)
{
MyCircle ShapeDrawn = new MyCircle();
ShapeDrawn.X = SplashKit.MouseX();
ShapeDrawn.Y = SplashKit.MouseY();
drawShape.AddShape(ShapeDrawn);
}
5.3C - Drawing Program - Saving and Loading

if (kindToAdd == ShapeKind.Line)
{
MyLine ShapeDrawn = new MyLine();
ShapeDrawn.X = SplashKit.MouseX();
ShapeDrawn.Y = SplashKit.MouseY();
drawShape.AddShape(ShapeDrawn);
}

Console.WriteLine("Mouse Left");

//End

if (SplashKit.MouseClicked(MouseButton.RightButton))
{
drawShape.SelectedShapeAt(SplashKit.MousePosition());
Console.WriteLine("Mouse Right");
}

//Start
//Additional Function
if (SplashKit.KeyDown(KeyCode.EscapeKey))
{
drawShape.ChangingShapeColor();
Console.WriteLine("ESC");
}

//End

if (SplashKit.KeyTyped(KeyCode.BackspaceKey) ||
SplashKit.KeyTyped(KeyCode.DeleteKey))
{
if (SplashKit.KeyTyped(KeyCode.BackspaceKey))
{
Console.WriteLine("Backspace");
}
if (SplashKit.KeyTyped(KeyCode.DeleteKey))
{
Console.WriteLine("Delete");
}
drawShape.RemoveShape();
}

if (SplashKit.KeyTyped(KeyCode.SpaceKey))
{
drawShape.Background = SplashKit.RandomRGBColor(255);
Console.WriteLine("SpaceKey");
}
//save n load
if (SplashKit.KeyDown(KeyCode.SKey))
{
drawShape.Save("G:/shapes (2).txt");

if (SplashKit.KeyTyped(KeyCode.OKey))
{
try
{
drawShape.Load("G:/shapes (2).txt");
5.3C - Drawing Program - Saving and Loading

}
catch (Exception e)
{
Console.Error.WriteLine("Error loading file: {0}",
e.Message);
}
}

drawShape.Draw();

SplashKit.RefreshScreen();

}
while (!SplashKit.WindowCloseRequested("Drawing Shape"));
}
}
}

Shape.cs
using MyGame;
using SplashKitSDK;
namespace Shapedrawerr

{
public abstract class Shape
{
private Color _color;
private float _x, _y;
private int _width, _height;
private bool _selected;

public Shape(Color clr)


{
_color = clr;
}

public Color COLOR


{
get
{
return _color;
}
set
{
_color = value;
}
}

public float X
{
get
{
return _x;
}
set
{
_x = value;
}
}
5.3C - Drawing Program - Saving and Loading

public float Y
{
get
{
return _y;
}
set
{
_y = value;
}
}

public abstract void Draw();

public abstract bool IsAt(Point2D p);

public bool Selected


{
get
{
return _selected;
}
set
{
_selected = value;
}
}
public virtual void SaveTo(StreamWriter writer)
{
writer.WriteColor(_color);
writer.WriteLine(X);
writer.WriteLine(Y);
}

public virtual void LoadFrom(StreamReader reader)


{
COLOR = reader.ReadColor();
X = reader.ReadInteger();
Y = reader.ReadInteger();
}

public abstract void DrawOutline();


}
}
5.3C - Drawing Program - Saving and Loading

Screenshot of program execution


First execution:

Pressing the S key will save the Drawing to


Desktop in a file named shapes(2).txt.
5.3C - Drawing Program - Saving and Loading

Location of saved Txt file:


5.3C - Drawing Program - Saving and Loading

Press “o” to Load

You might also like