public void SetUp()
        {
            _emptyToolbar = new ErrorToolbar();
            _filledToolbar = new ErrorToolbar();

            _raw = Substitute.For<IErrorDisplay>();
            _raw.PluginItem.Returns(new ToolStripButton());
            
            _browser = Substitute.For<IErrorDisplay>();
            _browser.PluginItem.Returns(new ToolStripButton());

            _filledToolbar.Register(_raw);
            _filledToolbar.Register(_browser);

            _rendererChangeNotification = false;
            _filledToolbar.SelectedRendererChanged += new EventHandler(_filledToolbar_SelectedRendererChanged);

            return;
        }
        public void SetUp()
        {
            _emptyToolbar = new ErrorToolbar();
            _filledToolbar = new ErrorToolbar();

            _rawMock = MockHelper.NewMockIErrorRenderer("raw", 1);
            _rawMock.SetReturnValue("get_PluginItem", new ToolStripButton());
            _raw = (IErrorDisplay)_rawMock.MockInstance;
            
            _browserMock = MockHelper.NewMockIErrorRenderer("browser", 2);
            _browserMock.SetReturnValue("get_PluginItem", new ToolStripButton());
            _browser = (IErrorDisplay)_browserMock.MockInstance;

            _filledToolbar.Register(_raw);
            _filledToolbar.Register(_browser);

            _rendererChangeNotification = false;
            _filledToolbar.SelectedRendererChanged += new EventHandler(_filledToolbar_SelectedRendererChanged);

            return;
        }
        private void item_Click(object sender, EventArgs e)
        {
            ToolStripItem item = sender as ToolStripItem;
            IErrorDisplay renderer;

            if (item == null || item.Tag == null)
                return;

            renderer = item.Tag as IErrorDisplay;
            if (renderer == null)
                return;

            SelectedDisplay = renderer;

            return;
        }                
        private int IndexOf(IErrorDisplay renderer)
        {
            int i;

            if (renderer == null)
                return (-1);

            for (i = 0; i < Items.Count; ++i)
                if (object.ReferenceEquals(Items[i].Tag, renderer))
                    return (i);

            return (-1);
        }       
        /// <summary>
        /// Register a new IErrorDisplay in the toolbar.
        /// </summary>
        public void Register(IErrorDisplay display)
        {
            ToolStripItem item;
            int sepIndex;

            UiExceptionHelper.CheckNotNull(display, "display");
            UiExceptionHelper.CheckNotNull(display.PluginItem, "display.PluginItem");

            item = display.PluginItem;
            item.Tag = display;
            item.Click += new EventHandler(item_Click);

            _displays.Add(display);
            sepIndex = Items.IndexOf(_separator);
            Items.Insert(sepIndex, item);

            if (display.OptionItems != null)
            {
                ToolStripItem[] array = display.OptionItems;
                foreach (ToolStripItem value in array)
                {
                    value.Visible = false;
                    Items.Add(value);
                }
            }

            if (_displays.Count == 1)
                SelectedDisplay = display;

            return;
        }
        /// <summary>
        /// Populates ErrorBrowser with the new display passed in parameter.
        /// If ErrorBrowser is empty, the display becomes automatically the
        /// new selected display.
        /// </summary>
        /// <param name="display"></param>
        public void RegisterDisplay(IErrorDisplay display)
        {
            UiExceptionHelper.CheckNotNull(display, "display");

            Toolbar.Register(display);
            display.OnStackTraceChanged(_stackStace);

            if (Toolbar.SelectedDisplay == null)
                Toolbar.SelectedDisplay = display;

            return;
        }
        public void ErrorDisplay_Plugins_life_cycle_events()
        {
            // test #1: Asks ErrorBrowser to register an instance of IErrorDisplay
            //
            // - check the process calls successively IErrorDisplay's
            //   properties & methods.
            //
            // - when registering an IErrorDisplay for the first time, ErrorBrowser
            //   should select the instance automatically.

            IErrorDisplay mockTraceDisplay  = Substitute.For <IErrorDisplay>();
            IErrorDisplay mockSourceDisplay = Substitute.For <IErrorDisplay>();

            ToolStripButton tracePlugin  = new ToolStripButton();
            Control         traceContent = new TextBox();

            mockTraceDisplay.PluginItem.Returns(tracePlugin);
            mockTraceDisplay.Content.Returns(traceContent);

            _errorBrowser.RegisterDisplay(mockTraceDisplay);

            mockTraceDisplay.Received().OnStackTraceChanged(_errorBrowser.StackTraceSource);

            Assert.That(_errorBrowser.SelectedDisplay, Is.Not.Null);
            Assert.That(_errorBrowser.SelectedDisplay, Is.SameAs(mockTraceDisplay));
            Assert.That(_errorBrowser.LayoutPanel.Content, Is.EqualTo(traceContent));

            // test #2: Asks ErrorBrowser to register another instance of IErrorDisplay
            //
            // - Selection should not change

            ToolStripItem sourcePluginItem = new ToolStripButton();
            Control       sourceContent    = new Button();

            mockSourceDisplay.PluginItem.Returns(sourcePluginItem);

            _errorBrowser.RegisterDisplay(mockSourceDisplay);

            Assert.That(_errorBrowser.SelectedDisplay, Is.Not.Null);
            Assert.That(_errorBrowser.SelectedDisplay, Is.SameAs(mockTraceDisplay));

            // test #3: changes current selection

            mockTraceDisplay.PluginItem.Returns(tracePlugin);
            mockSourceDisplay.Content.Returns(sourceContent);

            _errorBrowser.Toolbar.SelectedDisplay = mockSourceDisplay;

            Assert.That(_errorBrowser.Toolbar.SelectedDisplay, Is.SameAs(mockSourceDisplay));
            Assert.That(_errorBrowser.LayoutPanel.Content, Is.EqualTo(sourceContent));

            // test #4: changing ErrorSource update all renderers

            string stack = "à test() C:\\file.cs:ligne 1";

            _errorBrowser.StackTraceSource = stack;
            Assert.That(_errorBrowser.LayoutPanel.Content, Is.TypeOf(typeof(Button)));

            mockTraceDisplay.Received().OnStackTraceChanged(stack);
            mockSourceDisplay.Received().OnStackTraceChanged(stack);

            // clears all renderers

            _errorBrowser.ClearAll();
            Assert.That(_errorBrowser.Toolbar.Count, Is.EqualTo(0));

            Assert.That(_errorBrowser.LayoutPanel.Option, Is.Not.Null);
            Assert.That(_errorBrowser.LayoutPanel.Option, Is.TypeOf(typeof(Panel)));

            Assert.That(_errorBrowser.LayoutPanel.Content, Is.Not.Null);
            Assert.That(_errorBrowser.LayoutPanel.Content, Is.TypeOf(typeof(Panel)));

            return;
        }