private void ReportFunctions(LogicalCircuit root)
{
try {
CircuitMap map = new CircuitMap(root);
CircuitState state = map.Apply(1);
Dictionary <string, int> func = new Dictionary <string, int>();
foreach (CircuitFunction f in state.Functions)
{
string name = f.ReportName;
if (func.ContainsKey(name))
{
func[name]++;
}
else
{
func.Add(name, 1);
}
}
this.Functions = new List <string>(func.Keys);
this.Functions.Sort(StringComparer.Ordinal);
this.Usage = func;
} catch (Exception exception) {
this.BuildMapException = exception;
}
}
public Parameter AddParameter(Result result, CircuitMap circuitMap, Jam jam, int bitNumber)
{
Tracer.Assert(CircuitMap.IsPrimitive(jam.CircuitSymbol.Circuit));
SymbolMap map = this.AddSymbol(circuitMap, (CircuitSymbol)jam.CircuitSymbol);
return(map.AddParameter(result, circuitMap, jam, bitNumber));
}
private void RunningMapDoubleClick(object sender, MouseButtonEventArgs e)
{
try {
if (this.Editor != null && this.Editor.Power && e.ChangedButton == MouseButton.Left)
{
TreeView treeView = sender as TreeView;
if (treeView != null && treeView.SelectedItem != null)
{
CircuitMap map = treeView.SelectedItem as CircuitMap;
if (map != null)
{
this.Editor.OpenLogicalCircuit(map);
TreeViewItem item = this.Container(treeView, map);
if (item != null)
{
item.IsExpanded = true;
}
e.Handled = true;
}
}
}
} catch (Exception exception) {
Tracer.Report("MainFrame.RunningMapDoubleClick", exception);
this.ReportException(exception);
}
}
public Result AddResult(CircuitMap circuitMap, Jam jam, int bitNumber)
{
Tracer.Assert(CircuitMap.IsPrimitive(jam.CircuitSymbol.Circuit));
SymbolMap map = this.AddSymbol(circuitMap, (CircuitSymbol)jam.CircuitSymbol);
return(map.AddResult(circuitMap, jam, bitNumber));
}
public Parameter AddParameter(Result result, CircuitMap circuitMap, Jam jam, int bitNumber)
{
Tracer.Assert(circuitMap.Circuit == jam.CircuitSymbol.LogicalCircuit && jam.CircuitSymbol == this.key.CircuitSymbol);
JamKey jamKey = new JamKey(jam, bitNumber);
Parameter parameter;
if (this.parameters.TryGetValue(jamKey, out parameter))
{
if (!parameter.Result.IsTriState || !result.IsTriState)
{
if (parameter.Result == result && parameter.CircuitMap == circuitMap && parameter.Jam == jam && parameter.BitNumber == bitNumber)
{
return(parameter);
}
CircuitGlyph symbol = jam.CircuitSymbol;
throw new CircuitException(Cause.UserError,
Properties.Resources.ErrorManyResults(jam.Pin.Name, symbol.Circuit.Notation + symbol.Point.ToString())
);
}
parameter.Result.Link(result);
}
else
{
parameter = new Parameter(result, circuitMap, jam, bitNumber);
this.parameters.Add(jamKey, parameter);
result.Add(parameter);
}
return(parameter);
}
public static void Validate(LogicalCircuit logicalCircuit)
{
CircuitMap map = new CircuitMap(TableChank.Copy(logicalCircuit));
// this will throw if bit width error occurred.
map.Apply(1);
}
public WireDisplayControl(Canvas canvas, Point point, Wire wire) {
this.InitializeComponent();
Panel.SetZIndex(this, int.MaxValue);
Canvas.SetLeft(this, point.X - 3);
Canvas.SetTop(this, point.Y - 3);
canvas.Children.Add(this);
this.UpdateLayout();
if(this.CaptureMouse() && Mouse.LeftButton == MouseButtonState.Pressed) {
this.editor = App.Mainframe.Editor;
CircuitMap map = this.editor.CircuitRunner.VisibleMap;
Tracer.Assert(wire.LogicalCircuit == map.Circuit);
this.parameter = map.StateIndexes(wire).ToArray();
this.circuitState = this.editor.CircuitRunner.CircuitState;
if(0 < this.parameter.Length && this.circuitState != null) {
this.state = new State[this.parameter.Length];
this.bitWidth.Text = Properties.Resources.WireDisplayBitWidth(this.parameter.Length);
this.timer = new DispatcherTimer(DispatcherPriority.Normal, App.Mainframe.Dispatcher);
this.timer.Tick += TimerTick;
this.timer.Interval = new TimeSpan(0, 0, 0, 0, 1000 / (this.editor.IsMaximumSpeed ? 25 : Math.Min(25, this.editor.Frequency * 4)));
} else {
this.bitWidth.Text = Properties.Resources.WireDisplayDisconnected;
this.display.Visibility = Visibility.Collapsed;
}
} else {
this.Cancel();
}
}
public JamBit(CircuitMap map, Jam jam, int bit)
{
Tracer.Assert(map.Circuit == jam.CircuitSymbol.LogicalCircuit);
Tracer.Assert(0 <= bit && bit < jam.Pin.BitWidth);
this.map = map;
this.jam = jam;
this.bit = bit;
}
protected StateIndex(CircuitMap circuitMap, Jam jam, int bitNumber)
{
Tracer.Assert(circuitMap.Circuit == jam.CircuitSymbol.LogicalCircuit);
Tracer.Assert(jam.IsValid(bitNumber));
this.CircuitMap = circuitMap;
this.Jam = jam;
this.BitNumber = bitNumber;
}
public Result AddResult(CircuitMap circuitMap, Jam jam, int bitNumber)
{
Tracer.Assert(circuitMap.Circuit == jam.CircuitSymbol.LogicalCircuit && jam.CircuitSymbol == this.key.CircuitSymbol);
Result result = new Result(circuitMap, jam, bitNumber);
this.results.Add(new JamKey(jam, bitNumber), result);
return(result);
}
public void OpenLogicalCircuit(CircuitMap map)
{
Tracer.Assert(this.Power);
this.OpenLogicalCircuit(map.Circuit);
this.CircuitRunner.VisibleMap = map;
map.TurnOn();
map.Redraw(true);
this.Mainframe.Status = map.Path();
}
private void CircuitMapCleanUpTest(CircuitProject circuitProject, string logicalCircuitName, int expectedFunctions)
{
ProjectTester.SwitchTo(circuitProject, logicalCircuitName);
CircuitMap map = new CircuitMap(circuitProject.ProjectSet.Project.LogicalCircuit);
CircuitState state = map.Apply(CircuitRunner.HistorySize);
Assert.AreEqual(expectedFunctions, state.Functions.Count(), "wrong number of functions");
}
public Result(CircuitMap circuitMap, Jam jam, int bitNumber) : base(circuitMap, jam, bitNumber)
{
Tracer.Assert(jam.Pin.PinType == PinType.Output);
this.Parameters = new List <Parameter>();
if (jam.Pin.Circuit is Gate gate && (gate.GateType == GateType.TriState1 || gate.GateType == GateType.TriState2))
{
this.TriStateGroup = new HashSet <Result> {
this
};
}
}
public SymbolMap AddSymbol(CircuitMap circuitMap, CircuitSymbol circuitSymbol)
{
SymbolMapKey key = new SymbolMapKey(circuitMap, circuitSymbol);
SymbolMap map;
if (!this.symbols.TryGetValue(key, out map))
{
map = new SymbolMap(key);
this.symbols.Add(key, map);
}
return(map);
}
private void CircuitMapPerfTest(string project, string initialCircuit, int maxCount, int maxSeconds)
{
CircuitProject circuitProject = ProjectTester.Load(this.TestContext, project, initialCircuit);
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 0; i < maxCount; i++)
{
CircuitMap circuitMap = new CircuitMap(circuitProject.ProjectSet.Project.LogicalCircuit);
CircuitState circuitState = circuitMap.Apply(CircuitRunner.HistorySize);
Assert.IsNotNull(circuitState);
circuitMap.TurnOn();
}
stopwatch.Stop();
this.TestContext.WriteLine("{0} CircuitMap(s) created and applied in {1} - {2:N2} sec per each map", maxCount, stopwatch.Elapsed, stopwatch.Elapsed.TotalSeconds / maxCount);
Assert.IsTrue(stopwatch.Elapsed < new TimeSpan(0, 0, maxSeconds), "CircuitMap was created and applied successfully but too slow");
}
private void RunningMapTreeViewSelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
try {
if (sender == e.OriginalSource && e.NewValue != null && !object.ReferenceEquals(e.OldValue, e.NewValue))
{
CircuitMap map = e.NewValue as CircuitMap;
if (map != null)
{
TreeViewItem item = this.Container((TreeView)sender, map);
if (item != null)
{
item.IsExpanded = true;
item.BringIntoView();
}
}
}
} catch (Exception exception) {
Tracer.Report("MainFrame.RunningMapTreeViewSelectedItemChanged", exception);
this.ReportException(exception);
}
}
private TreeViewItem Container(TreeView treeView, CircuitMap map)
{
Tracer.Assert(map != null);
if (map.Parent == null)
{
return((TreeViewItem)treeView.ItemContainerGenerator.ContainerFromItem(map));
}
else
{
TreeViewItem parent = this.Container(treeView, map.Parent);
if (parent != null)
{
parent.IsExpanded = true;
return((TreeViewItem)parent.ItemContainerGenerator.ContainerFromItem(map));
}
else
{
return(null);
}
}
}
public TableChank(LogicalCircuit logicalCircuit)
{
this.LogicalCircuit = TableChank.Copy(logicalCircuit);
this.Plug();
// Create map and state
CircuitMap circuitMap = new CircuitMap(this.LogicalCircuit);
this.CircuitState = circuitMap.Apply(CircuitRunner.HistorySize);
this.Inputs.ForEach(s => s.Function = circuitMap.FunctionConstant(s.Symbol));
this.Outputs.ForEach(s => s.Function = circuitMap.FunctionProbe(s.Symbol));
this.Inputs.Where(s => s.Function == null).ToList().ForEach(s => this.Inputs.Remove(s));
this.Outputs.Where(s => s.Function == null).ToList().ForEach(s => this.Outputs.Remove(s));
Tracer.Assert(this.Inputs.All(s => s.Function != null) && this.Outputs.All(s => s.Function != null));
this.InputBitCount = this.Inputs.Sum(p => p.Pin.BitWidth);
this.Count = BigInteger.One << this.InputBitCount;
circuitMap.TurnOn();
}
public bool IsConnected(CircuitMap map, Jam jam, int bit)
{
return(!this.jamConnected.Add(new JamBit(map, jam, bit)));
}
public Parameter(Result result, CircuitMap circuitMap, Jam jam, int bitNumber) : base(circuitMap, jam, bitNumber)
{
Tracer.Assert(jam.Pin.PinType == PinType.Input);
this.Result = result;
}
public JamBit(CircuitMap circuitMap, Jam jam, int bit)
{
this.Map = circuitMap;
this.Jam = jam;
this.Bit = bit;
}
public SymbolMapKey(CircuitMap circuitMap, CircuitSymbol circuitSymbol)
{
this.CircuitMap = circuitMap;
this.CircuitSymbol = circuitSymbol;
}
protected override void Edit(Symbol symbol)
{
CircuitSymbol circuitSymbol = symbol as CircuitSymbol;
if (circuitSymbol != null)
{
if (this.InEditMode)
{
LogicalCircuit lc = circuitSymbol.Circuit as LogicalCircuit;
if (lc != null)
{
this.OpenLogicalCircuit(lc);
return;
}
CircuitProbe cp = circuitSymbol.Circuit as CircuitProbe;
if (cp != null)
{
this.Edit(cp);
return;
}
CircuitButton cb = circuitSymbol.Circuit as CircuitButton;
if (cb != null)
{
this.Edit(cb);
return;
}
Constant ct = circuitSymbol.Circuit as Constant;
if (ct != null)
{
this.Edit(ct);
return;
}
Sensor sr = circuitSymbol.Circuit as Sensor;
if (sr != null)
{
this.Edit(sr);
return;
}
Memory m = circuitSymbol.Circuit as Memory;
if (m != null)
{
this.Edit(m);
return;
}
Pin pin = circuitSymbol.Circuit as Pin;
if (pin != null)
{
this.Edit(pin);
return;
}
LedMatrix ledMatrix = circuitSymbol.Circuit as LedMatrix;
if (ledMatrix != null)
{
this.Edit(ledMatrix);
return;
}
Sound sound = circuitSymbol.Circuit as Sound;
if (sound != null)
{
this.Edit(sound);
return;
}
GraphicsArray graphicsArray = circuitSymbol.Circuit as GraphicsArray;
if (graphicsArray != null)
{
this.Edit(graphicsArray);
return;
}
}
else if (this.CircuitRunner != null && this.CircuitRunner.VisibleMap != null)
{
CircuitMap map = this.CircuitRunner.VisibleMap.Child(circuitSymbol);
if (map != null)
{
this.OpenLogicalCircuit(map);
return;
}
if (circuitSymbol.Circuit is CircuitProbe)
{
FunctionProbe functionProbe = this.CircuitRunner.VisibleMap.FunctionProbe(circuitSymbol);
if (functionProbe != null)
{
this.Mainframe.ShowDialog(new DialogProbeHistory(functionProbe));
}
return;
}
if ((circuitSymbol.Circuit is Memory) || (circuitSymbol.Circuit is GraphicsArray))
{
IFunctionMemory functionMemory = this.CircuitRunner.VisibleMap.FunctionMemory(circuitSymbol);
if (functionMemory != null)
{
this.Mainframe.ShowDialog(new DialogMemory(functionMemory));
}
return;
}
if (circuitSymbol.Circuit is Constant)
{
if (this.CircuitRunner.Root.First() == this.CircuitRunner.VisibleMap)
{
FunctionConstant functionConstant = this.CircuitRunner.VisibleMap.FunctionConstant(circuitSymbol);
if (functionConstant != null)
{
this.CircuitProject.InOmitTransaction(() => functionConstant.Value++);
}
}
else
{
this.Mainframe.Status = Properties.Resources.MessageNotRootConstant(this.CircuitRunner.Root.First().Circuit.Name);
}
}
}
}
else if (this.InEditMode)
{
TextNote textNote = symbol as TextNote;
if (textNote != null)
{
this.Edit(textNote);
}
}
}
