public bool LoadDocument(string fileName)
{
try
{
if (String.IsNullOrEmpty(fileName) == false)
{
CircuitData circuitData = CircuitSerializer.DeserializeCircuit(fileName);
circuitEditor.SignalList = SignalConverter.Instance.ConvertToSignalList(circuitData.Signals);
circuitEditor.Circuit = CircuitConverter.Instance.ConvertToCircuit(circuitData, circuitEditor.SignalList, true);
m_Simulation.Signals = circuitEditor.SignalList;
m_Simulation.Circuit = circuitEditor.Circuit;
FileName = fileName;
return(true);
}
}
catch (Exception e)
{
string msg = e.Message;
if (e.InnerException != null)
{
msg += "\n" + e.InnerException.Message;
}
MessageBox.Show(msg + "\n-----\n" + e.StackTrace, "Exception", MessageBoxButtons.OK, MessageBoxIcon.Stop);
}
return(false);
}
// Creates CircuitProbe wrapper
private CircuitProbe CreateItem(
// Fields of CircuitProbe table
Guid CircuitProbeId,
string Name,
string Note
// Fields of Circuit table
)
{
TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
CircuitData dataCircuit = new CircuitData()
{
CircuitId = CircuitProbeId
};
RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);
CircuitProbeData dataCircuitProbe = new CircuitProbeData()
{
CircuitProbeId = CircuitProbeId,
Name = Name,
Note = Note,
};
return(this.Create(this.Table.Insert(ref dataCircuitProbe), rowIdCircuit));
}
// Creates Constant wrapper
private Constant CreateItem(
// Fields of Constant table
Guid ConstantId,
int BitWidth,
int Value,
PinSide PinSide,
string Note
// Fields of Circuit table
)
{
TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
CircuitData dataCircuit = new CircuitData()
{
CircuitId = ConstantId
};
RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);
ConstantData dataConstant = new ConstantData()
{
ConstantId = ConstantId,
BitWidth = BitWidth,
Value = Value,
PinSide = PinSide,
Note = Note,
};
return(this.Create(this.Table.Insert(ref dataConstant), rowIdCircuit));
}
public void SerializeAndDeserialize()
{
var circuitToSave = new CircuitData();
var andGateData = new AndGateData();
var input1 = new InputData();
input1.Id = Guid.NewGuid();
var input2 = new InputData();
input2.Id = Guid.NewGuid();
andGateData.Input1 = input1;
andGateData.Input2 = input2;
andGateData.Delay = 10;
andGateData.Id = Guid.NewGuid();
circuitToSave.Elements.Add(andGateData);
CircuitData circuitToRead;
using (var stream = new MemoryStream())
{
CircuitDataWriter.Write(circuitToSave, stream);
stream.Seek(0, SeekOrigin.Begin); // przewinięcie z powrotem na początek
circuitToRead = CircuitDataReader.Read(stream);
}
var andGate = (AndGateData)circuitToRead.Elements[0];
Assert.AreEqual(andGateData.Id, andGate.Id);
Assert.AreEqual(andGateData.Delay, andGate.Delay);
}
// Creates LogicalCircuit wrapper
private LogicalCircuit CreateItem(
// Fields of LogicalCircuit table
Guid LogicalCircuitId,
string Name,
string Notation,
string Note,
string Category,
bool IsDisplay
// Fields of Circuit table
)
{
TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
CircuitData dataCircuit = new CircuitData()
{
CircuitId = LogicalCircuitId
};
RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);
LogicalCircuitData dataLogicalCircuit = new LogicalCircuitData()
{
LogicalCircuitId = LogicalCircuitId,
Name = Name,
Notation = Notation,
Note = Note,
Category = Category,
IsDisplay = IsDisplay,
};
return(this.Create(this.Table.Insert(ref dataLogicalCircuit), rowIdCircuit));
}
// Creates CircuitButton wrapper
private CircuitButton CreateItem(
// Fields of CircuitButton table
Guid CircuitButtonId,
string Notation,
bool IsToggle,
PinSide PinSide,
bool Inverted,
int Width,
int Height,
string Note
// Fields of Circuit table
)
{
TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
CircuitData dataCircuit = new CircuitData()
{
CircuitId = CircuitButtonId
};
RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);
CircuitButtonData dataCircuitButton = new CircuitButtonData()
{
CircuitButtonId = CircuitButtonId,
Notation = Notation,
IsToggle = IsToggle,
PinSide = PinSide,
Inverted = Inverted,
Width = Width,
Height = Height,
Note = Note,
};
return(this.Create(this.Table.Insert(ref dataCircuitButton), rowIdCircuit));
}
// Creates GraphicsArray wrapper
private GraphicsArray CreateItem(
// Fields of GraphicsArray table
Guid GraphicsArrayId,
bool WriteOn1,
MemoryOnStart OnStart,
int DataBitWidth,
int BitsPerPixel,
int Width,
int Height,
string Note
// Fields of Circuit table
)
{
TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
CircuitData dataCircuit = new CircuitData()
{
CircuitId = GraphicsArrayId
};
RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);
GraphicsArrayData dataGraphicsArray = new GraphicsArrayData()
{
GraphicsArrayId = GraphicsArrayId,
WriteOn1 = WriteOn1,
OnStart = OnStart,
DataBitWidth = DataBitWidth,
BitsPerPixel = BitsPerPixel,
Width = Width,
Height = Height,
Note = Note,
};
return(this.Create(this.Table.Insert(ref dataGraphicsArray), rowIdCircuit));
}
private void SaveAs(string fileName)
{
try
{
if (String.IsNullOrEmpty(fileName))
{
FileSelector fileSelector = new FileSelector(FileSelectorFilters.Circuits);
fileSelector.FileName = fileName;
if (fileSelector.ExecuteSaveDialog())
{
fileName = fileSelector.FileName;
}
}
if (String.IsNullOrEmpty(fileName) == false)
{
CircuitData data = CircuitConverter.Instance.ConvertFromCircuit(circuitEditor.Circuit);
data.Signals = SignalConverter.Instance.ConvertFromSignalList(circuitEditor.SignalList);
CircuitSerializer.SerializeCircuit(fileName, data);
m_Persistent = true;
FileName = fileName;
}
}
catch (Exception e)
{
string msg = e.Message;
if (e.InnerException != null)
{
msg += "\n" + e.InnerException.Message;
}
MessageBox.Show(msg + "\n-----\n" + e.StackTrace, "Exception", MessageBoxButtons.OK, MessageBoxIcon.Stop);
}
}
// Creates Sound wrapper
private Sound CreateItem(
// Fields of Sound table
Guid SoundId,
PinSide PinSide,
string Notation,
string Note
// Fields of Circuit table
)
{
TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
CircuitData dataCircuit = new CircuitData()
{
CircuitId = SoundId
};
RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);
SoundData dataSound = new SoundData()
{
SoundId = SoundId,
PinSide = PinSide,
Notation = Notation,
Note = Note,
};
return(this.Create(this.Table.Insert(ref dataSound), rowIdCircuit));
}
// Creates Sensor wrapper
private Sensor CreateItem(
// Fields of Sensor table
Guid SensorId,
SensorType SensorType,
int BitWidth,
PinSide PinSide,
string Notation,
string Data,
string Note
// Fields of Circuit table
)
{
TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
CircuitData dataCircuit = new CircuitData()
{
CircuitId = SensorId
};
RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);
SensorData dataSensor = new SensorData()
{
SensorId = SensorId,
SensorType = SensorType,
BitWidth = BitWidth,
PinSide = PinSide,
Notation = Notation,
Data = Data,
Note = Note,
};
return(this.Create(this.Table.Insert(ref dataSensor), rowIdCircuit));
}
public void SetData(CircuitData data)
{
simulationControl.SetData(data);
backgroundWorker.DoWork += backgroundWorker_DoWork;
backgroundWorker.ProgressChanged += backgroundWorker_ProgressChanged;
backgroundWorker.RunWorkerCompleted += backgroundWorker_RunWorkerCompleted;
}
/// <summary>
/// load circuti data from path
/// </summary>
public static bool LoadCircuitDatafromjson(string JsonData, ref CircuitData lab)
{
if (string.IsNullOrEmpty(JsonData) == true)
{
return(false);
}
lab = JsonUtility.FromJson <CircuitData>(JsonData);
return(true);
}
// Creates Circuit wrapper
private Circuit CreateItem(
// Fields of Circuit table
Guid CircuitId
)
{
CircuitData dataCircuit = new CircuitData()
{
CircuitId = CircuitId,
};
return(this.Create(this.Table.Insert(ref dataCircuit)));
}
private void LoadFiles()
{
button_ProceedToPage2.Enabled = false;
//at this point the chosen files really do exist
m_CircuitData = CircuitSerializer.DeserializeCircuit(textBox_Circuit.Text);
m_CircuitData.Signals = null;
Circuit circuit = CircuitConverter.Instance.ConvertToCircuit(m_CircuitData);
foreach (BaseElement be in circuit)
{
if (be is SignalInput)
{
ListViewItem li = new ListViewItem(be.Name);
//li.ToolTipText = String.Format("{0} ({1}, X: {2}, Y: {3})", be.);
li.Group = listView_CircuitIOs.Groups[0];
listView_CircuitIOs.Items.Add(li);
}
if (be is SignalOutput)
{
ListViewItem li = new ListViewItem(be.Name);
li.Group = listView_CircuitIOs.Groups[1];
listView_CircuitIOs.Items.Add(li);
}
}
m_SymbolData = SymbolSerializer.DeserializeSymbol(textBox_Symbol.Text);
Symbol symbol = SymbolConverter.Instance.ConvertToSymbol(m_SymbolData);
foreach (SymbolPart part in symbol)
{
if (part is PortPart)
{
PortPart port = (PortPart)part;
if (port.Direction == DirectionType.Input)
{
ListViewItem li = new ListViewItem(port.Name);
//li.ToolTipText = String.Format("{0} ({1}, X: {2}, Y: {3})", port.Name, port.Direction, port.Location.X, port.Location.Y);
li.Group = listView_SymbolPorts.Groups[0];
listView_SymbolPorts.Items.Add(li);
}
if (port.Direction == DirectionType.Output)
{
ListViewItem li = new ListViewItem(port.Name);
//li.ToolTipText = String.Format("{0} ({1}, X: {2}, Y: {3})", port.Name, port.Direction, port.Location.X, port.Location.Y);
li.Group = listView_SymbolPorts.Groups[1];
listView_SymbolPorts.Items.Add(li);
}
}
}
}
public void SetCircuitData(CircuitData data)
{
foreach (var elementData in data.Elements)
{
var control = CreateElementControl(elementData);
AddElementControl(control, elementData.X, elementData.Y);
control.SetData(elementData);
}
foreach (var wire in data.Wires)
{
AddWire(wire);
}
}
// Constructor
public CircuitSet(CircuitProject store)
{
ITableSnapshot table = store.Table("Circuit");
if (table != null)
{
Debug.Assert(store.IsFrozen, "The store should be frozen");
this.Table = (TableSnapshot <CircuitData>)table;
}
else
{
Debug.Assert(!store.IsFrozen, "In order to create table, the store should not be frozen");
this.Table = CircuitData.CreateTable(store);
}
this.InitializeCircuitSet();
}
public CircuitData BuildData()
{
var data = new CircuitData();
foreach (var element in elements)
{
data.Elements.Add(element.BuildData());
}
foreach (var wire in Wires)
{
data.Wires.Add(wire.BuildData());
}
return(data);
}
public static bool LoadCircuitData(string labfile, ref CircuitData lab)
{
try
{
FileStream fsFile = new FileStream(labfile, FileMode.Open);
StreamReader srReader = new StreamReader(fsFile);
string Text = srReader.ReadToEnd();
srReader.Close();
LoadCircuitDatafromjson(Text, ref lab);
}
catch (Exception e)
{
throw e;
}
return(true);
}
// Creates Gate wrapper
private Gate CreateItem(
// Fields of Gate table
Guid GateId
// Fields of Circuit table
)
{
TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
CircuitData dataCircuit = new CircuitData()
{
CircuitId = GateId
};
RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);
GateData dataGate = new GateData()
{
GateId = GateId,
};
return(this.Create(this.Table.Insert(ref dataGate), rowIdCircuit));
}
public CircuitBuilder(CircuitData circuitData, Simulation simulation)
{
this.circuitData = circuitData;
this.simulation = simulation;
Register(new AndGateBuilder());
Register(new BufferBuilder());
Register(new OrGateBuilder());
Register(new ExnorGateBuilder());
Register(new XorGateBuilder());
Register(new NandGateBuilder());
Register(new NotGateBuilder());
Register(new NorGateBuilder());
Register(new SwitchBuilder());
Register(new DiodeBuilder());
Register(new FlipFlopBuilder());
Register(new GeneratorBuilder());
Register(new IntegratedCircuitBuilder());
Register(new FreeInputBuilder());
Register(new FreeOutputBuilder());
}
public void SetCircuitData(CircuitData data)
{
circuitControl1.SetCircuitData(data);
}
public CircuitSimulator(CircuitData circuitData)
{
this.circuitData = circuitData;
}
public void SetData(CircuitData data)
{
circuitData = data;
BuildControls();
}
public void Notify(object sender, OperationEnum ev)
{
if (ev == OperationEnum.StartSimulation)
{
Console.WriteLine(@"Please, provide a path to the circuit file!");
userPathInput = Console.ReadLine();
Notify(this, OperationEnum.CheckedFile);
}
if (ev == OperationEnum.CheckedFile)
{
_fileReaderContext.CheckFile(userPathInput);
if (_fileReaderContext.fileIsValid && _fileReaderContext.fileType != null)
{
Notify(this, OperationEnum.InterpretFile);
}
else
{
Notify(this, OperationEnum.RestartSimulation);
}
}
if (ev == OperationEnum.InterpretFile)
{
_fileData = _fileReaderContext.ReadFile(userPathInput);
_lineInterpreter.InterpretData(_fileData.FileDictionary, _fileData.EdgeDictonary);
_circuitInputs = _lineInterpreter.CircuitInputs;
Notify(this, OperationEnum.BuildCircuit);
}
if (ev == OperationEnum.BuildCircuit)
{
CircuitBuilderMaker cbm = new CircuitBuilderMaker(_fileData, _circuitInputs);
_circuitData = cbm.GetCircuit();
if (!_circuitData.NoError)
{
Console.WriteLine(_circuitData.ErrorMessage);
Notify(this, OperationEnum.RestartSimulation);
}
Notify(this, OperationEnum.RunCircuit);
}
if (ev == OperationEnum.RunCircuit)
{
foreach (NodeComponent nodeInput in _circuitData.NodeComponent.OutputNodeList)
{
nodeInput.SetValue(SetInputs(nodeInput.Name));
}
Notify(this, OperationEnum.InputUser);
}
if (ev == OperationEnum.InputUser)
{
Console.WriteLine("Use on of the following commands: \"restart\" \"reset\" \"quit\"");
string input = Console.ReadLine().ToLower();
switch (input)
{
case CommandHandler.RESTART:
Notify(this, OperationEnum.RestartSimulation);
break;
case CommandHandler.RESET:
foreach (NodeComponent nodeInput in _circuitData.NodeComponent.OutputNodeList)
{
nodeInput.ResetCircuit();
}
Console.Clear();
Notify(this, OperationEnum.RunCircuit);
break;
case CommandHandler.QUIT:
Environment.Exit(0);
break;
default:
Console.WriteLine("Unknown command");
Notify(this, OperationEnum.InputUser);
break;
}
}
if (ev == OperationEnum.RestartSimulation)
{
Console.WriteLine();
Console.WriteLine("Press any key to restart application");
Console.ReadKey();
Console.Clear();
Notify(this, OperationEnum.StartSimulation);
}
}
