Esempio n. 1
0
        public DialogGraphicsArray(GraphicsArray graphicsArray)
        {
            this.graphicsArray       = graphicsArray;
            this.parsedWidth         = this.graphicsArray.Width;
            this.parsedHeight        = this.graphicsArray.Height;
            this.GraphicsArrayWidth  = this.parsedWidth.ToString(Properties.Resources.Culture);
            this.GraphicsArrayHeight = this.parsedHeight.ToString(Properties.Resources.Culture);

            this.DataContext = this;
            this.InitializeComponent();

            this.dataBitWidth.ItemsSource = GraphicsArrayDescriptor.DataBitWidthRange;
            this.bitsPerPixel.ItemsSource = GraphicsArrayDescriptor.BitsPerPixelRange;

            IEnumerable <EnumDescriptor <bool> > writeOnList = MemoryDescriptor.WriteOnList;

            this.writeOn.ItemsSource = writeOnList;

            EnumDescriptor <MemoryOnStart>[] onStartList = new EnumDescriptor <MemoryOnStart>[] {
                new EnumDescriptor <MemoryOnStart>(MemoryOnStart.Random, Properties.Resources.MemoryOnStartRandom),
                new EnumDescriptor <MemoryOnStart>(MemoryOnStart.Zeros, Properties.Resources.MemoryOnStartZeros),
                new EnumDescriptor <MemoryOnStart>(MemoryOnStart.Ones, Properties.Resources.MemoryOnStartOnes),
                //new EnumDescriptor<MemoryOnStart>(MemoryOnStart.Data, Properties.Resources.MemoryOnStartData)
            };
            this.onStart.ItemsSource = onStartList;

            this.dataBitWidth.SelectedItem = this.graphicsArray.DataBitWidth;
            this.bitsPerPixel.SelectedItem = this.graphicsArray.BitsPerPixel;
            this.writeOn.SelectedItem      = writeOnList.First(d => d.Value == this.graphicsArray.WriteOn1);
            this.onStart.SelectedItem      = onStartList.First(d => d.Value == this.graphicsArray.OnStart);
            this.note.Text = this.graphicsArray.Note;
        }
        private void CreateDevicePins(GraphicsArray graphicsArray)
        {
            Tracer.Assert(!this.CircuitProject.DevicePinSet.SelectByCircuit(graphicsArray).Any());
            // The order of creation of the pins is essential for expansion algorithm.

            DevicePin address = this.CircuitProject.DevicePinSet.Create(graphicsArray, PinType.Input, graphicsArray.AddressBitWidth);

            address.PinSide = PinSide.Left;
            address.Name    = Properties.Resources.MemoryAddressPinName;
            DevicePin data = this.CircuitProject.DevicePinSet.Create(graphicsArray, PinType.Output, graphicsArray.DataBitWidth);

            data.PinSide = PinSide.Right;
            data.Name    = Properties.Resources.MemoryDataPinName;

            DevicePin dataIn = this.CircuitProject.DevicePinSet.Create(graphicsArray, PinType.Input, graphicsArray.DataBitWidth);

            dataIn.PinSide = PinSide.Left;
            dataIn.Name    = Properties.Resources.MemoryDataInPinName;
            DevicePin write = this.CircuitProject.DevicePinSet.Create(graphicsArray, PinType.Input, 1);

            write.PinSide = PinSide.Bottom;
            write.Name    = Properties.Resources.MemoryWritePinName(graphicsArray.WriteOn1 ? Properties.Resources.WriteOn1 : Properties.Resources.WriteOn0);
            graphicsArray.SetPins(address, data, dataIn, write);
            GraphicsArraySet.UpdateWritePinName(graphicsArray);
        }
        public FunctionGraphicsArray(
            CircuitState circuitState,
            int[] address,
            int[] inputData,
            int[] outputData,
            int write,
            IEnumerable <CircuitSymbol> symbols
            ) : base(circuitState, FunctionMemory.Input(address, null, inputData, write), outputData)
        {
            this.circuitSymbol = symbols.ToList();
            Tracer.Assert(0 < this.circuitSymbol.Count);

            GraphicsArray graphicsArray = (GraphicsArray)this.circuitSymbol[0].Circuit;

            this.project = graphicsArray.CircuitProject.ProjectSet.Project;

            this.address   = address;
            this.inputData = inputData;
            this.write     = write;
            this.writeOn   = graphicsArray.WriteOn1 ? State.On1 : State.On0;

            Tracer.Assert(this.inputData.Length == outputData.Length && this.inputData.Length == graphicsArray.DataBitWidth);

            this.bitsPerPixel = graphicsArray.BitsPerPixel;
            this.drawingRect  = new Int32Rect(0, 0, graphicsArray.Width, graphicsArray.Height);

            int w = this.drawingRect.Width * this.bitsPerPixel;

            this.memoryStride = w / this.DataBitWidth + (((w % this.DataBitWidth) == 0) ? 0 : 1);
            int byteStride = w / 8 + (((w % 8) == 0) ? 0 : 1);

            this.bitmapStride = Math.Max(byteStride * 8, this.memoryStride * this.DataBitWidth) / 8;
            Tracer.Assert(this.memoryStride * this.DataBitWidth <= this.bitmapStride * 8);
            this.zoom = graphicsArray.Zoom;

            switch (graphicsArray.OnStart)
            {
            case MemoryOnStart.Random:
                this.data = this.Allocate();
                circuitState.Random.NextBytes(this.data);
                break;

            case MemoryOnStart.Zeros:
                this.data = this.Allocate();
                break;

            case MemoryOnStart.Ones:
                this.data = this.Allocate();
                for (int i = 0; i < this.data.Length; i++)
                {
                    this.data[i] = 0xFF;
                }
                break;

            case MemoryOnStart.Data:
            default:
                Tracer.Fail();
                break;
            }
        }
        private GraphicsArray Register(RowId rowId)
        {
            CircuitData data = new CircuitData()
            {
                CircuitId = this.Table.GetField(rowId, GraphicsArrayData.GraphicsArrayIdField.Field)
            };
            GraphicsArray graphicsArray = this.Create(rowId, this.CircuitProject.CircuitTable.Insert(ref data));

            this.CreateDevicePins(graphicsArray);
            return(graphicsArray);
        }
        public static int AddressBitsFor(int dataBitWidth, int bitsPerPixel, int width, int height)
        {
            int bits = 0;
            int max  = GraphicsArray.NumberCellsFor(dataBitWidth, bitsPerPixel, width, height) - 1;

            while (max != 0)
            {
                bits++;
                max >>= 1;
            }
            return(Math.Max(1, bits));
        }
        public GraphicsArray Copy(GraphicsArray other)
        {
            GraphicsArrayData data;

            other.CircuitProject.GraphicsArraySet.Table.GetData(other.GraphicsArrayRowId, out data);
            if (this.FindByGraphicsArrayId(data.GraphicsArrayId) != null)
            {
                data.GraphicsArrayId = Guid.NewGuid();
            }
            data.GraphicsArray = null;
            return(this.Register(this.Table.Insert(ref data)));
        }
Esempio n. 7
0
        public GraphicsArray Create(int dataBitWidth, int bitsPerPixel, int width, int height)
        {
            GraphicsArray graphicsArray = this.CreateItem(Guid.NewGuid(),
                                                          GraphicsArrayData.WriteOn1Field.Field.DefaultValue,
                                                          GraphicsArrayData.OnStartField.Field.DefaultValue,
                                                          dataBitWidth,
                                                          bitsPerPixel,
                                                          width,
                                                          height,
                                                          GraphicsArrayData.NoteField.Field.DefaultValue
                                                          );

            this.CreateDevicePins(graphicsArray);
            return(graphicsArray);
        }
Esempio n. 8
0
        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);
                }
            }
        }
Esempio n. 9
0
 private void Edit(GraphicsArray graphicsArray)
 {
     this.Mainframe.ShowDialog(new DialogGraphicsArray(graphicsArray));
 }
Esempio n. 10
0
 public static void UpdateWritePinName(GraphicsArray graphicsArray)
 {
     graphicsArray.WritePin.Name = Properties.Resources.MemoryWritePinName(graphicsArray.WriteOn1 ? Properties.Resources.WriteOn1 : Properties.Resources.WriteOn0);
 }
Esempio n. 11
0
 protected override int CircuitSymbolHeight(int defaultHeight)
 {
     return(base.CircuitSymbolHeight(Math.Max(3, GraphicsArray.PixelsToGridSize(this.Height * this.Zoom))));
 }
Esempio n. 12
0
 protected override int CircuitSymbolWidth(int defaultWidth)
 {
     return(base.CircuitSymbolWidth(Math.Max(2, GraphicsArray.PixelsToGridSize(this.Width * this.Zoom))));
 }