Vista Internet Explorer 7 Style Navigate Button Control

Download source - 87.33 KB

Introduction

This is a Vista Internet Explorer 7 style navigate button control. Sorry! My English is bad. Please download the source and try it.

The Code Preview

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Reflection;
using System.IO;

namespace Demo.Controls
{
    #region TravelButton
    [DefaultEvent("ItemClicked")]
    public partial class TravelButton : Control
    {
        #region Fields
        [Browsable(true)]
        public event TravelButtonItemClickedEventHandler ItemClicked;
        [Browsable(false)]
        public event EventHandler DropDownMenuChanged;

        private readonly Rectangle BACKGROUND_RECT = 
                         new Rectangle(0, 0, 74, 29);
        private readonly Rectangle BACK_BUTTON_RECT = 
                         new Rectangle(2, 2, 25, 25);
        private readonly Rectangle FORWARD_BUTTON_RECT = 
                         new Rectangle(30, 2, 25, 25); 
        private readonly Rectangle DROPDOWN_ARROW_RECT = 
                         new Rectangle(57, 4, 17, 20);

        private Image _backGround = null;
        private Image _backButton = null;
        private Image _forwardButton = null;

        private ControlState _bButtonState = ControlState.Normal;
        private ControlState _fButtonState = ControlState.Normal;
        private ControlState _ddArrowState = ControlState.Normal;

        private bool _bButtonEnabled = true;
        private bool _fButtonEnabled = true;
        private bool _showMenu = true;

        private string _bToolTip = null;
        private string _fToolTip = null;
        private string _curToolTip = null;

        private ContextMenuStrip _dropDownMenu = null;

        private enum ControlState
        {
            Normal,
            Hover,
            Pressed,
            Disabled
        }
        #endregion

        #region Constructors
        public TravelButton()
        {
            Assembly assembly = Assembly.GetAssembly(typeof(TravelButton));

            _backGround = new Bitmap(
              assembly.GetManifestResourceStream(
              "Demo.Resources.BACKGROUND.PNG"));
            _backButton = new Bitmap(
              assembly.GetManifestResourceStream(
              "Demo.Resources.LEFTBUTTON.PNG"));
            _forwardButton = new Bitmap(
              assembly.GetManifestResourceStream(
              "Demo.Resources.RIGHTBUTTON.PNG"));

            this.DoubleBuffered = true;

            InitializeComponent();
        }
        #endregion

        #region Properties
        [Category("Behavior"), Browsable(true), DefaultValue(true)]
        public bool BackEnabled
        {
            get
            {
                return _bButtonEnabled;
            }
            set
            {
                _bButtonEnabled = value;
                this.Invalidate();
            }
        }

        [Category("Behavior"), Browsable(true), DefaultValue(true)]
        public bool ForwardEnabled
        {
            get
            {
                return _fButtonEnabled;
            }
            set
            {
                _fButtonEnabled = value;
                this.Invalidate();
            }
        }

        [Browsable(true)]
        public string BackToolTip
        {
            get
            {
                return _bToolTip;
            }
            set
            {
                _bToolTip = value;
            }
        }

        [Browsable(true)]
        public string ForwardToolTip
        {
            get
            {
                return _fToolTip;
            }
            set
            {
                _fToolTip = value;
            }
        }

        [Category("Behavior"), Browsable(true), DefaultValue(null)]
        public ContextMenuStrip DropDownMenu
        {
            get
            {
                return _dropDownMenu;
            }
            set
            {
                if (!DesignMode && _dropDownMenu != null)
                    _dropDownMenu.VisibleChanged -= 
                      new EventHandler(DropDownMenu_VisibleChanged);
                
                _dropDownMenu = value;

                if (!DesignMode && _dropDownMenu != null)
                    _dropDownMenu.VisibleChanged += 
                      new EventHandler(DropDownMenu_VisibleChanged);

                if (DropDownMenuChanged != null)
                    DropDownMenuChanged(this, EventArgs.Empty);
            }
        }
        #endregion

        #region Override
        protected override void OnEnabledChanged(EventArgs e)
        {
            base.OnEnabledChanged(e);
            this.Invalidate();
        }

        protected override void OnPaint(PaintEventArgs pe)
        {
            if (this.Enabled)
            {
                if (ForwardEnabled)
                    DrawItem(pe.Graphics, TravelButtonItem.BackGround, 
                             _ddArrowState);
                else
                    DrawItem(pe.Graphics, TravelButtonItem.BackGround, 
                             ControlState.Disabled);

                if (BackEnabled)
                    DrawItem(pe.Graphics, TravelButtonItem.BackButton, 
                             _bButtonState);
                else
                    DrawItem(pe.Graphics, TravelButtonItem.BackButton, 
                             ControlState.Disabled);

                if (ForwardEnabled)
                    DrawItem(pe.Graphics, TravelButtonItem.ForwardButton,
                             _fButtonState);
                else
                    DrawItem(pe.Graphics, TravelButtonItem.ForwardButton, 
                             ControlState.Disabled);
            }
            else
            {
                DrawItem(pe.Graphics, TravelButtonItem.BackGround, 
                         ControlState.Disabled);
                DrawItem(pe.Graphics, TravelButtonItem.BackButton, 
                         ControlState.Disabled);
                DrawItem(pe.Graphics, TravelButtonItem.ForwardButton, 
                         ControlState.Disabled);
            }

            base.OnPaint(pe);
        }

        protected override void OnMouseLeave(EventArgs e)
        {
            base.OnMouseLeave(e);

            _bButtonState = ControlState.Normal;
            _fButtonState = ControlState.Normal;

            if (_dropDownMenu != null && _dropDownMenu.Visible)
                _ddArrowState = ControlState.Pressed;
            else
                _ddArrowState = ControlState.Normal;

            this.Invalidate();

            _showMenu = true;
            _curToolTip = null;
            //toolTip.Hide(this);
        }

        protected override void OnMouseDown(MouseEventArgs me)
        {
            base.OnMouseDown(me);

            if (this.Enabled)
            {
                if (me.Button == MouseButtons.Left)
                {
                    if (BackEnabled && 
                        BACK_BUTTON_RECT.Contains(me.X, me.Y))
                    {
                        _bButtonState = ControlState.Pressed;
                        _fButtonState = ControlState.Normal;
                        _ddArrowState = ControlState.Normal;
                        _showMenu = true;
                    }
                    else if (ForwardEnabled && 
                             FORWARD_BUTTON_RECT.Contains(me.X, me.Y))
                    {
                        _bButtonState = ControlState.Normal;
                        _fButtonState = ControlState.Pressed;
                        _ddArrowState = ControlState.Normal;
                        _showMenu = true;
                    }
                    else if (ForwardEnabled && 
                             DROPDOWN_ARROW_RECT.Contains(me.X, me.Y))
                    {
                        _bButtonState = ControlState.Normal;
                        _fButtonState = ControlState.Normal;

                        if (_dropDownMenu != null)
                        {
                            if (_showMenu)
                            {
                                _dropDownMenu.Show(this, 
                                  new Point(BACKGROUND_RECT.X, 
                                  BACKGROUND_RECT.Height),
                                  ToolStripDropDownDirection.Default);
                                _ddArrowState = ControlState.Pressed;
                            }
                            else
                            {
                                _ddArrowState = ControlState.Hover;
                            }
                            _showMenu = !_showMenu;
                        }
                        else
                        {
                            _ddArrowState = ControlState.Hover;
                            _showMenu = true;
                        }
                    }
                    else
                    {
                        _bButtonState = ControlState.Normal;
                        _fButtonState = ControlState.Normal;
                        _ddArrowState = ControlState.Normal;
                        _showMenu = true;
                    }

                    this.Invalidate();
                }
            }
        }

        protected override void OnMouseMove(MouseEventArgs me)
        {
            base.OnMouseMove(me);

            if (this.Enabled && !this.Capture)
            {
                if (BackEnabled && BACK_BUTTON_RECT.Contains(me.X, me.Y))
                {
                    _bButtonState = ControlState.Hover;
                    _fButtonState = ControlState.Normal;
                    _ddArrowState = ControlState.Normal;

                    SetToolTip(TravelButtonItem.BackButton);
                }
                else if (ForwardEnabled && FORWARD_BUTTON_RECT.Contains(me.X, me.Y))
                {
                    _bButtonState = ControlState.Normal;
                    _fButtonState = ControlState.Hover;
                    _ddArrowState = ControlState.Normal;

                    SetToolTip(TravelButtonItem.ForwardButton);
                }
                else if (ForwardEnabled && DROPDOWN_ARROW_RECT.Contains(me.X, me.Y))
                {
                    _bButtonState = ControlState.Normal;
                    _fButtonState = ControlState.Normal;
                    _ddArrowState = ControlState.Hover;

                    SetToolTip(TravelButtonItem.DropDownArrow);
                }
                else
                {
                    _bButtonState = ControlState.Normal;
                    _fButtonState = ControlState.Normal;
                    _ddArrowState = ControlState.Normal;

                    SetToolTip(TravelButtonItem.BackGround);
                }

                this.Invalidate();
            }
        }

        protected override void OnMouseDoubleClick(MouseEventArgs me)
        {
            if (DROPDOWN_ARROW_RECT.Contains(me.X, me.Y))
                return;
            else
                base.OnMouseDoubleClick(me);
        }

        protected override void OnClick(EventArgs e)
        {
            if (this.Enabled)
            {
                Point p = this.PointToClient(Control.MousePosition);
                TravelButtonItem item = TravelButtonItem.BackGround;

                if (BackEnabled && BACK_BUTTON_RECT.Contains(p.X, p.Y))
                {
                    item = TravelButtonItem.BackButton;
                    _bButtonState = ControlState.Hover;
                }
                else if (ForwardEnabled && FORWARD_BUTTON_RECT.Contains(p.X, p.Y))
                {
                    item = TravelButtonItem.ForwardButton;
                    _fButtonState = ControlState.Hover;
                }
                else if (ForwardEnabled && DROPDOWN_ARROW_RECT.Contains(p.X, p.Y))
                {
                    item = TravelButtonItem.DropDownArrow;
                    //_dropDownArrowState = ControlState.Hover;
                }

                this.Invalidate();

                if (item != TravelButtonItem.BackGround && 
                    ItemClicked != null)
                    ItemClicked(this, new TravelButtonItemClickedEventArgs(item));
            }

            base.OnClick(e);
        }
        #endregion

        #region Pulbic
        public void SetEnabled(TravelButtonItem item, bool enable)
        {
            if (item == TravelButtonItem.BackButton)
                this.BackEnabled = enable;
            else if (item == TravelButtonItem.ForwardButton
                || item == TravelButtonItem.DropDownArrow)
                this.ForwardEnabled = enable;
        }

        public void SetToolTip(TravelButtonItem item, string tip)
        {
            if (item == TravelButtonItem.BackButton)
                this.BackToolTip = tip;
            else if (item == TravelButtonItem.ForwardButton
                || item == TravelButtonItem.DropDownArrow)
                this.ForwardToolTip = tip;
        }
        #endregion

        #region Private
        private void SetToolTip(TravelButtonItem item)
        {
            if (item == TravelButtonItem.BackButton)
            {
                if (_curToolTip != _bToolTip)
                {
                    _curToolTip = _bToolTip;
                    toolTip.SetToolTip(this, _curToolTip);
                }
            }
            else if (item == TravelButtonItem.ForwardButton)
            {
                if (_curToolTip != _fToolTip)
                {
                    _curToolTip = _fToolTip;
                    toolTip.SetToolTip(this, _curToolTip);
                }
            }
            else
            {
                _curToolTip = null;
                toolTip.Hide(this);
            }
        }

        private void DropDownMenu_VisibleChanged(object sender, EventArgs e)
        {
            ContextMenuStrip menu = sender as ContextMenuStrip;
            if (menu != null)
            {
                if (!menu.Visible)
                {
                    _ddArrowState = ControlState.Normal;
                }

                this.Invalidate();
            }
        }

        private void DrawItem(Graphics g, TravelButtonItem item, 
                              ControlState state)
        {
            Rectangle srcRect;
            switch (item)
            {
                case TravelButtonItem.BackButton:
                    srcRect = new Rectangle(new Point(0, 0),
                              BACK_BUTTON_RECT.Size);
                    break;
                case TravelButtonItem.ForwardButton:
                    srcRect = new Rectangle(new Point(0, 0), 
                              FORWARD_BUTTON_RECT.Size);
                    break;
                default:
                    srcRect = BACKGROUND_RECT;
                    break;
            }

            int xOffset = 0;
            switch (state)
            {
                case ControlState.Normal:
                    xOffset = 0;
                    break;
                case ControlState.Pressed:
                    xOffset = srcRect.Width;
                    break;
                case ControlState.Hover:
                    xOffset = srcRect.Width * 2;
                    break;
                case ControlState.Disabled:
                    xOffset = srcRect.Width * 3;
                    break;
            }

            srcRect.X = xOffset;

            if (item == TravelButtonItem.BackButton)
            {
                g.DrawImage(_backButton, BACK_BUTTON_RECT, srcRect, 
                            GraphicsUnit.Pixel);
            }
            else if (item == TravelButtonItem.ForwardButton)
            {
                g.DrawImage(_forwardButton, FORWARD_BUTTON_RECT, 
                            srcRect, GraphicsUnit.Pixel);
            }
            else if (item == TravelButtonItem.BackGround)
            {
                g.DrawImage(_backGround, BACKGROUND_RECT, 
                            srcRect, GraphicsUnit.Pixel);
            }
        }
        #endregion
    }
    #endregion

    #region Other
    public delegate void TravelButtonItemClickedEventHandler(
           object sender, TravelButtonItemClickedEventArgs e);

    public enum TravelButtonItem
    {
        BackGround,
        BackButton,
        ForwardButton,
        DropDownArrow
    }
    
    public class TravelButtonItemClickedEventArgs : EventArgs
    {
        private readonly TravelButtonItem _item = 
                         TravelButtonItem.BackGround;

        public TravelButtonItemClickedEventArgs(TravelButtonItem clickedItem)
                                                                     : base()
        {
            _item = clickedItem;
        }

        public TravelButtonItem ClickedItem
        {
            get
            {
                return _item;
            }
        }
    }
    #endregion
}

History

2008-2-25: Added ToolStripButton and suboptimal support for Gradient background

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

About the Author

YuReng

Web Developer

China

Member

cool chappy.

Article Top

Poor

Excellent

Add a reason or comment to your vote: x
Votes of 3 or less require a comment

Comments and Discussions

You must Sign In to use this message board. (secure sign-in)

Search this forum
	Profile popups Noise Layout Per page

Vista don't allow AppInit_Dlls to inject

sunil_2008

20:41 4 Sep '09

Hi Friends, Vista for Internet Explorer, doesn't allow to inject any DLL present in HKLM\SOFTWARE\MICROSOFT\Windows NT\CurrentVersion\Windows\AppInit_Dlls. I've also set the entry LoadAppInit_Dlls to 1. When IE start, it stop working. Please, help me to solve the problem. Thanks, Sunil.
Sign In·View Thread·Permalink

backbuttononly should hide the background placeholder so can use it to mimic vista wizard

Member 717928

16:44 14 Jul '09

backbuttononly should hide the background placeholder so can use it to mimic vista wizard also would be good to sign the control so if insert dll in project it would be compliant But for the rest it is really a good control Thanks you very much
Sign In·View Thread·Permalink

A request...

Johnny J.

5:51 5 Feb '08

Very nice control. Is there any chance that you can amend the source to support the BLACK design found in eg. Windows Media Player??? Cheers, Johnny
Sign In·View Thread·Permalink

Resources

elronalds

15:30 9 May '07

What file did you extract the PNG images from? Thanks
Sign In·View Thread·Permalink

Re: Resources

YuReng

17:37 7 Jun '07

sorry! i belated, use 'ResHacker 3.5'
Sign In·View Thread·Permalink

Re: Resources

The Dogcow Farmer

6:28 13 Aug '08

I think's it's browseui.dll or ieframe.dll.

Chuck Norris has the greatest Poker-Face of all time. He won the 1983 World Series of Poker, despite holding only a Joker, a Get out of Jail Free Monopoloy card, a 2 of clubs, 7 of spades and a green #4 card from the game UNO.

In the movie "The Matrix", Chuck Norris is the Matrix. If you pay close attention in the green "falling code" scenes, you can make out the faint texture of his beard.

Chuck Norris actually owns IBM. It was an extremely hostile takeover.

Great! Support for Gradient background?

Dr. Bonne

0:19 20 Oct '06

Very cool control! Big Grin | :-D

Is it possible to let the control support gradient backgrounds.

If I host the control in a custom drawn Panel with a gradient background (see below), the gradient is not visible in the transparent part of your control.



protected override void OnPaintBackground(PaintEventArgs e)

{

   base.OnPaintBackground(e);

   Graphics g = e.Graphics;

   using (LinearGradientBrush brush = new LinearGradientBrush(

      new Rectangle(0, 0, this.Width, this.Height), SystemColors.ActiveCaption,

      SystemColors.GradientActiveCaption, LinearGradientMode.Vertical))

   {

      g.FillRectangle(brush, this.Location.X, this.Location.Y, this.Width, this.Height);

   }

}

Thanks!