public FrameworkElement CreateLedMatrixGlyph(CircuitGlyph mainSymbol)
{
Canvas canvas = this.CreateGlyphCanvas(mainSymbol);
if (this == mainSymbol)
{
CircuitGlyph.AddJam(canvas, this.Jams(), null);
}
FrameworkElement shape = CircuitGlyph.Skin(canvas, SymbolShape.LedMatrix);
UniformGrid grid = shape.FindName("ProbeView") as UniformGrid;
Tracer.Assert(grid != null);
if (this == mainSymbol)
{
this.ProbeView = grid;
}
LedMatrix matrix = (LedMatrix)this.Circuit;
grid.Columns = matrix.Columns;
grid.Rows = matrix.Rows;
string skin = (matrix.CellShape == LedMatrixCellShape.Round) ? SymbolShape.LedMatrixRoundCell : SymbolShape.LedMatrixRectCell;
int cellCount = matrix.Rows * matrix.Columns;
for (int i = 0; i < cellCount; i++)
{
grid.Children.Add(Symbol.Skin(skin));
}
return(canvas);
}
private LedMatrix Register(RowId rowId)
{
CircuitData data = new CircuitData()
{
CircuitId = this.Table.GetField(rowId, LedMatrixData.LedMatrixIdField.Field)
};
LedMatrix ledMatrix = this.Create(rowId, this.CircuitProject.CircuitTable.Insert(ref data));
ledMatrix.UpdatePins();
return(ledMatrix);
}
public LedMatrix Copy(LedMatrix other)
{
LedMatrixData data;
other.CircuitProject.LedMatrixSet.Table.GetData(other.LedMatrixRowId, out data);
if (this.FindByLedMatrixId(data.LedMatrixId) != null)
{
data.LedMatrixId = Guid.NewGuid();
}
data.LedMatrix = null;
return(this.Register(this.Table.Insert(ref data)));
}
/// <summary>
/// Creates function. Assumes parameter layout: first goes columns states starting from column 0, bit 0 to bit 2. After all columns goes rows they are one bit wide.
/// </summary>
/// <param name="circuitState"></param>
/// <param name="symbol"></param>
/// <param name="parameter"></param>
public FunctionLedMatrixSelector(CircuitState circuitState, IEnumerable <CircuitSymbol> symbols, int[] parameter) : base(circuitState, symbols, parameter)
{
LedMatrix matrix = this.Matrix;
this.row = new State[matrix.Rows];
int columns = matrix.Columns;
this.column = new int[columns];
this.columnChanged = new bool[columns];
this.cell = new int[this.column.Length * this.row.Length];
this.cellFlip = new int[this.column.Length * this.row.Length];
this.rowParameter = columns * this.BitPerLed;
}
public DialogLedMatrix(LedMatrix ledMatrix)
{
this.LedMatrix = ledMatrix;
this.MatrixType = LedMatrixDescriptor.LedMatrixTypeDescriptor(this.LedMatrix.MatrixType);
this.CellShape = (int)this.LedMatrix.CellShape;
this.Rows = this.LedMatrix.Rows;
this.Columns = this.LedMatrix.Columns;
this.ColorRange = PinDescriptor.NumberRange(LedMatrix.MinBitsPerLed, LedMatrix.MaxBitsPerLed);
this.Colors = ledMatrix.Colors;
this.Note = this.LedMatrix.Note;
this.DataContext = this;
this.InitializeComponent();
}
public LedMatrix Create(LedMatrixType ledMatrixType, int rows, int columns)
{
LedMatrix ledMatrix = this.CreateItem(Guid.NewGuid(),
ledMatrixType,
LedMatrixData.CellShapeField.Field.DefaultValue,
rows,
columns,
LedMatrixData.ColorsField.Field.DefaultValue,
LedMatrixData.NoteField.Field.DefaultValue
);
ledMatrix.UpdatePins();
return(ledMatrix);
}
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);
}
}
}
private void Edit(LedMatrix ledMatrix)
{
this.Mainframe.ShowDialog(new DialogLedMatrix(ledMatrix));
}
public FunctionLedMatrixIndividual(CircuitState circuitState, IEnumerable <CircuitSymbol> symbols, int[] parameter) : base(circuitState, symbols, parameter)
{
LedMatrix matrix = this.Matrix;
this.state = new int[matrix.Rows * matrix.Columns];
}
