public Register(IBasket basket, IDisplay display, IScanner scanner)
        {
            logger = LoggerFactory.GetLogger();

            this.basket = basket;
            this.display = display;
            this.scanner = scanner;

            basket.OnAdd += display.AddProduct;
            basket.AddSuccess += scanner.FlashLed;
            basket.AddFail += scanner.FlashLed;
            basket.OnUpdate += display.UpdateProduct;
            basket.OnRemove += display.RemoveProduct;
            basket.OnUpdateTotalCost += display.UpdateTotalCost;
            basket.OnUpdateProductCount += display.UpdateProductCount;

            display.OnStartScan += scanner.Start;
            display.OnStopScan += scanner.Stop;
            display.OnClear += basket.Clear;

            scanner.OnRead += new OnReadHandler(scanner_OnRead);

            logger.Write("Register", LogLevel.INFO, "Register initialized");

            display.Display();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            // Clean up previous contents
            clearFormControls();

            // Determine which species the user wants (see code below)
            String speciesName = getCheckedSpecies();

            // Get a List of the relevant Critters from the catalogue
            // YOU WILL NEED TO WRITE THE CRITTERQUERY METHOD
            List<Critter> selectedCritters = mainCatalogue.CritterQuery(speciesName);
            int critterCount = selectedCritters.Count;

            if (critterCount == 0)
            {
                MessageBox.Show("No critters of that species");
            }
            else
            {
                if (critterCount > pictureBoxList.Count)
                    displayMachine = textDisplayMachine;    // Will show images
                else
                    displayMachine = pictureDisplayMachine; // Will print text

                // clear any old contents. Part of IDisplay, so the Form knows it will work
                displayMachine.clearDisplay();

                // Make the call here. Behaviour will depend on which strategy your
                // instance implements.
                displayMachine.displayCritterList(selectedCritters);
            }
        }

 public void DoWork(Card[] cards, ITrello trello, IDisplay display)
 {
     foreach (var card in cards.Select(x => new ReleaseNotesCard(x)))
     {
         display.Write(string.Format("{0} - {1}", card.Labels, card.Name));
     }
 }

        public void DrawEditSymbol(IGeometry geometry, IDisplay display)
        {
            IEngineEditProperties engineProperty = new EngineEditorClass();

            ISymbol pointSymbol = engineProperty.SketchVertexSymbol as ISymbol;
            ISymbol sketchSymbol = engineProperty.SketchSymbol as ISymbol;

            ITopologicalOperator pTopo = geometry as ITopologicalOperator;

            sketchSymbol.SetupDC(display.hDC, display.DisplayTransformation);
            sketchSymbol.Draw(pTopo.Boundary);

            IPointCollection pointCol = geometry as IPointCollection;
            for (int i = 0; i < pointCol.PointCount; i++)
            {
                IPoint point = pointCol.get_Point(i);
                pointSymbol.SetupDC(display.hDC, display.DisplayTransformation);
                pointSymbol.Draw(point);
                pointSymbol.ResetDC();
            }

            ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(sketchSymbol);
            ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(pointSymbol);
            ESRI.ArcGIS.ADF.ComReleaser.ReleaseCOMObject(engineProperty);
        }

        public BorrowController(IDisplay display, ICardReader reader, IScanner scanner, IPrinter printer,
                                    IBookDAO bookDAO, ILoanDAO loanDAO, IMemberDAO memberDAO)
        {
            if(display == null) throw new ArgumentException("Display object was not provided to begin the application");
            if (reader == null) throw new ArgumentException("Reader object was not provided to begin the application");
            if (scanner == null) throw new ArgumentException("Scanner object was not provided to begin the application");
            if (printer == null) throw new ArgumentException("Printer object was not provided to begin the application");
            if (bookDAO == null) throw new ArgumentException("BookDAO object was not provided to begin the application");
            if (loanDAO == null) throw new ArgumentException("LoanDAO object was not provided to begin the application");
            if (memberDAO == null) throw new ArgumentException("MemberDAO object was not provided to begin the application");

            _display = display;
            _reader = reader;
            _scanner = scanner;
            _printer = printer;

            _bookDAO = bookDAO;
            _loanDAO = loanDAO;
            _memberDAO = memberDAO;

            _ui = new BorrowControl(this);

            _reader.Listener = this;
            _scanner.Listener = this;

            _bookList = new List<IBook>();
            _loanList = new List<ILoan>();

            _state = EBorrowState.CREATED;
        }

 public void render(IDisplay display)
 {
     this.display = display;
     display.imageBegin(imageWidth, imageHeight, 32);
     // set members variables
     bucketCounter = 0;
     // start task
     SunflowSharp.Systems.Timer timer = new SunflowSharp.Systems.Timer();
     timer.start();
     BucketThread[] renderThreads = new BucketThread[scene.getThreads()];
     for (int i = 0; i < renderThreads.Length; i++)
     {
         renderThreads[i] = new BucketThread(this);
         renderThreads[i].setPriority(scene.getThreadPriority());
         renderThreads[i].start();
     }
     for (int i = 0; i < renderThreads.Length; i++)
     {
         try
         {
             renderThreads[i].join();
         }
         catch (Exception e)
         {
             UI.printError(UI.Module.BCKT, "Bucket processing thread {0} of {1} was interrupted", i + 1, renderThreads.Length);
         }
     }
     timer.end();
     UI.printInfo(UI.Module.BCKT, "Render time: {0}", timer.ToString());
     display.imageEnd();
 }

 public DisplayHandler(IDisplay _display)
 {
   this.display = _display;
   this.heightInChars = Settings.Instance.TextHeight;
   if (this.heightInChars == 1)
   {
     this.heightInCharsSim = 2;
   }
   else
   {
     this.heightInCharsSim = this.heightInChars;
   }
   this.widthInChars = Settings.Instance.TextWidth;
   this.pixelsToScroll = Settings.Instance.PixelsToScroll;
   this.widthInPixels = Settings.Instance.GraphicWidth;
   this.heightInPixels = Settings.Instance.GraphicHeight;
   this.charsToScroll = Settings.Instance.CharsToScroll;
   this.forceGraphicText = Settings.Instance.ForceGraphicText;
   this.lines = new Line[this.heightInCharsSim];
   this.prevLines = new string[this.heightInChars];
   this.posSkips = new int[this.heightInChars];
   this.pos = new int[this.heightInChars];
   font = new Font(Settings.Instance.Font, (float)Settings.Instance.FontSize);
   for (int i = 0; i < this.heightInCharsSim; i++)
   {
     this.lines[i] = new Line();
   }
   for (int i = 0; i < this.heightInChars; i++)
   {
     this.pos[i] = 0;
   }
 }

		/// <summary>
		/// Initializes a new instance of the <see cref="AbsoluteLayoutWithDisplayInfoPage" /> class.
		/// </summary>
		/// <param name="display">The display.</param>
		public AbsoluteLayoutWithDisplayInfoPage(IDisplay display)
		{
			this.Title = "Absolute Layout With Display Info";
			var abs = new AbsoluteLayout();
			var inchX = display.WidthRequestInInches(1);
			var inchY = display.HeightRequestInInches(1);
			var originX = display.WidthRequestInInches(display.ScreenWidthInches() / 2);
			var originY = display.HeightRequestInInches(display.ScreenHeightInches() / 2);

			abs.Children.Add(new Label() { Text = "1\"x\"1\" blue frame" });

			abs.Children.Add(new Frame()
				{
					BackgroundColor = Color.Navy,
				},
				new Rectangle(originX - inchX/2, originY - inchY/2, inchX, inchY));

			abs.Children.Add(new Frame()
				{
					BackgroundColor = Color.White
				},
				new Rectangle(originX - inchX/16, originY - inchY/16, inchX/8, inchY/8));

			this.Content = abs;
		}

        private string RenderInfinite(string content, IDisplay display)
        {
            // append " - "
            content += " - ";

            // update scroll position
            if (_scrollDirection != 0 && _lastPositionChange.Add(Speed) < DateTime.Now)
            {
                _position++;

                // reset position at end and pause
                if (_position >= content.Length)
                {
                    _position = 0;
                    _scrollDirection = 0;
                }

                _lastPositionChange = DateTime.Now;
            }

            // start again after pause
            if (_scrollDirection == 0 && _lastPositionChange.Add(Pause) < DateTime.Now)
            {
                _scrollDirection = 1;
            }

            var partLength = (content.Length - _position > display.Columns 
                ? display.Columns 
                : content.Length - _position);

            return content.Substring(_position, partLength) + content.Substring(0, display.Columns - partLength);
        }

 public SolveRun(ICubeConfigurationGenerator generator, ISolver solver, IDisplay display, ICelebrator celebrator, int cubeSize)
 {
     m_display = display;
     m_celebrator = celebrator;
     m_solver = solver;
     m_generator = generator;
     m_cubeSize = cubeSize;
 }

        public ChatUser(string username, IDisplay display)
        {
            if (username == null) 
                throw new Exception("Username is null");
            Username = username;

            Display = display;
        }

        public CPU(Memory memory, IDisplay display, IKeyboard keyboard)
        {
            this.memory = memory;
            this.display = display;
            this.keyboard = keyboard;
            this.DelayTimer = new SimpleTimer();
            this.SoundTimer = new SimpleTimer();

            this.RandomFunc = this.RandomGenerator;

            InstructionSet[0x0] = SYS;
            InstructionSet[0x1] = JP;
            InstructionSet[0x2] = CALL;
            InstructionSet[0x3] = SE;
            InstructionSet[0x4] = SNE;
            InstructionSet[0x5] = SEV;
            InstructionSet[0x6] = LD;
            InstructionSet[0x7] = ADD;
            InstructionSet[0x8] = REG;
            InstructionSet[0x9] = SNEV;
            InstructionSet[0xA] = LDI;
            InstructionSet[0xB] = JPV;
            InstructionSet[0xC] = RND;
            InstructionSet[0xD] = DRW;
            InstructionSet[0xE] = SKP;
            InstructionSet[0xF] = LDS;

            // used with REG
            RegisterCommands[0x0] = (x, y) => Register[x] = Register[y];
            RegisterCommands[0x1] = (x, y) => Register[x] |= Register[y];
            RegisterCommands[0x2] = (x, y) => Register[x] &= Register[y];
            RegisterCommands[0x3] = (x, y) => Register[x] ^= Register[y];
            RegisterCommands[0x4] = (x, y) =>
                {
                    Register[0xf] = (byte)((Register[x] + Register[y]) > 0xff ? 1 : 0);
                    Register[x] += Register[y];
                };
            RegisterCommands[0x5] = (x, y) =>
                                        {
                                            Register[0xf] = (byte) (Register[x] > Register[y] ? 1 : 0);
                                            Register[x] -= Register[y];
                                        };
            RegisterCommands[0x6] = (x, y) =>
                                        {
                                            Register[0xf] = (byte) (Register[x] & 0x1);
                                            Register[x] = (byte) (Register[x] >> 1);
                                        };
            RegisterCommands[0x7] = (x, y) =>
            {
                Register[0xf] = (byte)(Register[x] < Register[y] ? 1 : 0);
                Register[x] = (byte) (Register[y] - Register[x]);
            };
            RegisterCommands[0xe] = (x, y) =>
            {
                Register[0xf] = (byte)(Register[x] >> 7);
                Register[x] = (byte)(Register[x] << 1);
            };
        }

        public CoinChanger(IDisplay d, CoinStorage changeBox)
        {
            brain = new CircuitBoard();
            coinID = new CoinIdentify();
            storage = new CoinStorage();

            display = d;
            returnChange = changeBox;
        }

 public BorrowControlTests()
 {
     _display = Substitute.For<IDisplay>();
     _reader = Substitute.For<ICardReader>();
     _scanner = Substitute.For<IScanner>();
     _printer = Substitute.For<IPrinter>();
     _bookDao = Substitute.For<IBookDAO>();
     _loanDao = Substitute.For<ILoanDAO>();
     _memberDao = Substitute.For<IMemberDAO>();
 }

        public void DoWork(Card[] cards, ITrello trello, IDisplay display)
        {
            display.Skip();
            display.Write("Archiving cards...");

            foreach (var card in cards)
            {
                trello.Cards.Archive(card);
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="FontManagerPage"/> class.
        /// </summary>
        /// <param name="display">The display.</param>
        /// <param name="fontManager">The font manager.</param>
        public FontManagerPage(IDisplay display, IFontManager fontManager)
        {
            var stack = new StackLayout();

            foreach (var namedSize in Enum.GetValues(typeof(NamedSize)))
            {
                var font = Font.SystemFontOfSize((NamedSize)namedSize);

                var height = fontManager.GetHeight(font);

                var heightRequest = display.HeightRequestInInches(height);

                var label = new Label()
                {
                    Font = font,
                    HeightRequest = heightRequest + 10,
                    Text = string.Format("System font {0} is {1:0.000}in tall.", namedSize, height),
                    XAlign = TextAlignment.Center
                };

                stack.Children.Add(label);
            }

            var f = Font.SystemFontOfSize(24);

            var inchFont = fontManager.FindClosest(f.FontFamily, fontSize);

            stack.Children.Add(new Label()
            {
                Text = "The below text should be " + fontSize + "in height from its highest point to lowest.",
                XAlign = TextAlignment.Center
            });


            stack.Children.Add(new Label()
            {
                Text = "FfTtLlGgJjPp",
                TextColor = Color.Lime,
                FontSize = inchFont.FontSize,
//                BackgroundColor = Color.Gray,
//                FontFamily = inchFont.FontFamily,
                XAlign = TextAlignment.Center,
                YAlign = TextAlignment.Start
            });


            stack.Children.Add(new Label()
            {
                Text = fontSize + "in height = SystemFontOfSize(" + inchFont.FontSize + ")",
                XAlign = TextAlignment.Center,
                YAlign = TextAlignment.End
            });

            this.Content = stack;
        }

 public void Run(IGraph g, IDisplay d)
 {
     IVertex v = g.vertexes()[0];
     v.setMark (true);
     foreach (IEdge e in v.edges()) {
         e.setMark (true);
         e.vto().setMark (true);
         d.update();
     }
     System.Console.WriteLine ("I am ok!");
 }

        public void DoWork(Card[] cards, ITrello trello, IDisplay display)
        {
            var cardsGroupedByLabel = cards
                                        .Select(x => new ReleaseNotesCard(x))
                                        .GroupBy(x => x.Labels)
                                        .ToArray();

            File.WriteAllText(_options.Output,
                              Razor.Parse(File.ReadAllText(_options.Template),
                                          new { _options.SoftwareName, _options.SoftwareVersion, Groups = cardsGroupedByLabel }));
        }

        public Chip8Cpu(IDisplay display, IRandomizer randomizer, IKeyboard keyboard, IBcdConverter bcdConverter, IInstructionDecoder instructionDecoder, ITimerClock timerClock)
        {
            _display = display;
            _randomizer = randomizer;
            _keyboard = keyboard;
            _bcdConverter = bcdConverter;
            _instructionDecoder = instructionDecoder;
            _timerClock = timerClock;

            State = new CpuState();
        }

            protected override void Context()
            {
                base.Context();

                Display = A.Fake<IDisplay>();
                InputMonitor = A.Fake<IInputMonitor>();
                Calculator = A.Fake<IStringCalculator>();

                Sut = new Program(Display, InputMonitor, Calculator);
                Sut.Initialize();
            }