La première étape consiste à créer un nouveau projet :



Ensuite nous faisons hériter la classe ExtendedTabControl de TabControl

public partial class ExtendedTabControl : TabControl
{
    public ExtendedTabControl()
    {
        InitializeComponent();
    }
}

Vous remarquerez au passage la classe avec laquelle nous travaillons est une classe partielle c'est-à-dire qu'elle est définie dans plusieurs fichiers.
En effet, l'éditeur de ressources de Visual Studio 2005 génère deux fichiers (en plus des ressources) pour gérer les formulaires, les contrôles... Le premier porte le nom MonControle.Designer.cs et est exploité quasi exclusivement par le designer (en gros, tout ce qui était dans la région [Component Designer Generated Code] de Visual Studio 2003 se retrouve dans ce fichier). Le deuxième qui a le nom MonControle.cs est celui ou vous pourrez écrire votre code pour gérer les évènements par exemple.

Le fait de séparer les informations de la classe sur deux fichiers permet aux développeurs de ne pas corrompre le code généré par le designer (ce qui est plus facile si l'ensemble se trouve dans un fichier unique).

Maintenant nous allons créer le contrôle composite qui va se substituer au TabControl au moment de l'exécution. Celui-ci est un TableLayoutPanel.Ce contrôle est propre à la version 2.0 de .Net et permet de ranger les contrôles à la mode tableau de HTML.
Notre contrôle va contenir une colonne et trois lignes (une pour chaque zone). Sur la première et dernière ligne nous allons y attacher un ToolStrip. Il s'agit aussi d'un nouveau contrôle qui permet d'avoir des zones pour accueillir des menus, toolbar... qui ont un look Office 2003. Ces zones vont accueillir les boutons qui vont remplacer les TabPages :



Nos ToolStrip ont les particularités suivantes :

1. GripStyle (zone permettant le déplacement de la ToolStrip) : masqué
2. LayoutStyle (sens d'affichage des éléments) : vertical
3. RenderMode (style d'affichage graphique de la zone) : manager render mode

GripStyle :



LayoutStyle (horizontal et vertical):



Render mode (system et manager render mode):



Ensuite sur notre TabControl étendu nous allons utiliser la technique présentée par Mitsuru Futura pour cacher les onglets si on n'est pas en mode design ou si le style n'est pas de type TabControl :

public override Rectangle DisplayRectangle
{
    get
    {
        if (DesignMode || style == ExtendedTabControlStyle.TabControl)
        {
            return base.DisplayRectangle;
        }
        else
        {
            if (Width != size.Width || Height != size.Height)
            {
                size.Width = Width;
                size.Height = Height;
                rect = Rectangle.Empty;
            }

            if (rect == Rectangle.Empty)
                rect = new Rectangle(0, 0, Width, Height);
            return rect;
        }
    }
}

Il ne nous reste plus qu'à intervenir au moment de la création pour remplacer le TabControl par la TableLayout si nous ne sommes plus en mode design.

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

    if (!DesignMode &&
        !(this.Parent == tableLayoutPanel))
    {
        System.Windows.Forms.Control.ControlCollection col = this.Parent.Controls;
        for (int i = 0; i < col.Count; ++i)
        {
            if (this == col[i])
            {
                col.Add(this.tableLayoutPanel);
                col.SetChildIndex(this.tableLayoutPanel, i);
                col.Remove(this);
                this.tableLayoutPanel.Controls.Add(this, 0, 1);
                break;
            }
        }

        foreach (TabPage tp in Controls)
        {
            tp.Padding = padding;
            tp.Margin = padding;
        }

        this.tableLayoutPanel.Padding = padding;
        this.tableLayoutPanel.Margin = padding;
        this.tableLayoutPanel.Dock = this.Dock;


        this.Dock = DockStyle.Fill;

        Synchronize();
        if (defaultTab >= ToolStripButtonCollection.Count)
            defaultTab = 0;
        if (0 != ToolStripButtonCollection.Count)
            Update(defaultTab);
    }
}

Ensuite nous allons régler le padding (marges internes) et le margin (marges externes) puis appeler la fonction Synchronize pour créer les boutons nécessaires et utiles dans le ToolStrip pour remplacer les onglets :

private void Synchronize()
{
    ToolStripButtonCollection.Clear();
    ToolStripSeparatorCollection.Clear();
    int Index = 0;

    foreach (TabPage tp in this.TabPages)
    {
        Index = AddNewButton(tp, Index);
    }
}

A chaque click sur les boutons du ToolStrip il faut faire bouger les boutons du bas vers le haut ou l'inverse su on est en mode Toolbox.

private void Update(ToolStripButton tsb)
{
    if (null == tsb) return;

    topToolStrip.Items.Clear();
    bottomToolStrip.Items.Clear();

    int MaxBottomSize =
        bottomToolStrip.GripStyle == ToolStripGripStyle.Visible ?
            bottomToolStrip.GripRectangle.Height + bottomToolStrip.GripMargin.Size.Height : 0;
    int MaxTopSize =
        topToolStrip.GripStyle == ToolStripGripStyle.Visible ?
            topToolStrip.GripRectangle.Height + topToolStrip.GripMargin.Size.Height : 0;

    if (style != ExtendedTabControlStyle.TabControl)
    {
        bool FirstBottom = true;
        bool FirstTop = true;

        int i = 0;
        foreach (ToolStripButton btn in ToolStripButtonCollection)
        {
            btn.Checked = false;

            if (((int)btn.Tag) > ((int)tsb.Tag) ||
                style == ExtendedTabControlStyle.Outlook)
            {
                if (!FirstBottom)
                {
                    ToolStripSeparator toolStripSeparator = ToolStripSeparatorCollection[i];
                    bottomToolStrip.Items.Add(toolStripSeparator);
                    MaxBottomSize += toolStripSeparator.Bounds.Height;
                }
                FirstBottom = false;
                bottomToolStrip.Items.Add(btn);
                MaxBottomSize += btn.Bounds.Height + btn.Padding.Size.Height;
            }
            else
            {
                if (!FirstTop)
                {
                    ToolStripSeparator toolStripSeparator = ToolStripSeparatorCollection[i];
                    topToolStrip.Items.Add(toolStripSeparator);
                    MaxTopSize += toolStripSeparator.Bounds.Height;
                }
                FirstTop = false;
                topToolStrip.Items.Add(btn);
                MaxTopSize += btn.Bounds.Height + btn.Padding.Size.Height;
            }

            ++i;
        }
    }
    tableLayoutPanel.RowStyles[0].Height = MaxTopSize;
    tableLayoutPanel.RowStyles[2].Height = MaxBottomSize;

    tsb.Checked = true;
    SelectedIndex = (int)tsb.Tag;
}