c# - deshabilitar - Cómo ocultar TabPage de TabControl

deshabilitar pestaña tabcontrol c#

Question

Esta pregunta ya tiene una respuesta aquí:

• Ocultar y mostrar TabPages en tabControl 16 respuestas

¿Cómo ocultar TabPage de TabControl en WinForms 2.0?

Answer 1

Variante 1

Para evitar visual klikering es posible que necesite usar:

bindingSource.RaiseListChangeEvent = false 

o

myTabControl.RaiseSelectedIndexChanged = false

Eliminar una página de pestaña:

myTabControl.Remove(myTabPage);

Agregar una página de pestaña:

myTabControl.Add(myTabPage);

Insertar una página de pestaña en una ubicación específica:

myTabControl.Insert(2, myTabPage);

No olvides invertir los cambios:

bindingSource.RaiseListChangeEvent = true;

o

myTabControl.RaiseSelectedIndexChanged = true;

Variante 2

myTabPage.parent = null;
myTabPage.parent = myTabControl;

Answer 2

+1 para Microsoft :-).
Logré hacerlo de esta manera:
(supone que tiene un botón ''Siguiente'' que muestra el siguiente tabulador - tabSteps es el nombre del control Tab)
Al inicio, guarde todos los tabuladores en una lista adecuada. Cuando el usuario presiona el botón Siguiente, elimine todos los tabuladores en el control de pestañas, luego agregue eso con el índice adecuado:

        int step = -1;
        List<TabPage> savedTabPages;

        private void FMain_Load(object sender, EventArgs e) {
            // save all tabpages in the list
            savedTabPages = new List<TabPage>();
            foreach (TabPage tp in tabSteps.TabPages) {
                savedTabPages.Add(tp);
            }
            SelectNextStep();
        }

        private void SelectNextStep() {
            step++;
            // remove all tabs
            for (int i = tabSteps.TabPages.Count - 1; i >= 0 ; i--) {
                    tabSteps.TabPages.Remove(tabSteps.TabPages[i]);
            }

            // add required tab
            tabSteps.TabPages.Add(savedTabPages[step]);
        }

        private void btnNext_Click(object sender, EventArgs e) {
            SelectNextStep();
        }

Actualizar

public class TabControlHelper {
    private TabControl tc;
    private List<TabPage> pages;
    public TabControlHelper(TabControl tabControl) {
        tc = tabControl;
        pages = new List<TabPage>();
        foreach (TabPage p in tc.TabPages) {
            pages.Add(p);
        }
    }

    public void HideAllPages() {
        foreach(TabPage p in pages) {
            tc.TabPages.Remove(p);
        }
    }

    public void ShowAllPages() {
        foreach (TabPage p in pages) {
            tc.TabPages.Add(p);
        }
    }

    public void HidePage(TabPage tp) {
        tc.TabPages.Remove(tp);
    }        

    public void ShowPage(TabPage tp) {
        tc.TabPages.Add(tp);
    }
}  

Answer 3

Bueno, si no quiere estropear el código existente y solo quiere ocultar una pestaña, puede modificar el código generado por el compilador para comentar la línea que agrega la pestaña al tabcontrol.

Por ejemplo: la siguiente línea agrega una pestaña llamada "readformatcardpage" a un Tabcontrol llamado "tabcontrol"

this.tabcontrol.Controls.Add (this.readformatcardpage);

Lo siguiente evitará que se agregue la pestaña al tabcontrol

// this.tabcontrol.Controls.Add(this.readformatcardpage);

Answer 4

Combiné la respuesta de @Jack Griffin y la de @amazedsaint ( http://www.dotnetspider.com/resources/18344-Hiding-Showing-Tabpages-Tabcontrol.aspx ) en un solo TabControlHelper .

El TabControlHelper te permite:

• Mostrar / Ocultar todas las páginas con pestañas
• Mostrar / Ocultar páginas con una sola pestaña
• Mantener la posición original de las páginas de pestañas
• Cambiar las páginas de pestañas

public class TabControlHelper
{
    private TabControl _tabControl;
    private List<KeyValuePair<TabPage, int>> _pagesIndexed;
    public TabControlHelper(TabControl tabControl)
    {
        _tabControl = tabControl;
        _pagesIndexed = new List<KeyValuePair<TabPage, int>>();

        for (int i = 0; i < tabControl.TabPages.Count; i++)
        {
            _pagesIndexed.Add(new KeyValuePair<TabPage, int> (tabControl.TabPages[i], i ));
        }
    }

    public void HideAllPages()
    {
        for (int i = 0; i < _pagesIndexed.Count; i++)
        {
            _tabControl.TabPages.Remove(_pagesIndexed[i].Key);
        }
    }

    public void ShowAllPages()
    {
        for (int i = 0; i < _pagesIndexed.Count; i++)
        {
            _tabControl.TabPages.Add(_pagesIndexed[i].Key);
        }
    }

    public void HidePage(TabPage tabpage)
    {
        if (!_tabControl.TabPages.Contains(tabpage)) return;
        _tabControl.TabPages.Remove(tabpage);
    }

    public void ShowPage(TabPage tabpage)
    {
        if (_tabControl.TabPages.Contains(tabpage)) return;
        InsertTabPage(GetTabPage(tabpage).Key, GetTabPage(tabpage).Value);
    }

    private void InsertTabPage(TabPage tabpage, int index)
    {
        if (index < 0 || index > _tabControl.TabCount)
            throw new ArgumentException("Index out of Range.");
        _tabControl.TabPages.Add(tabpage);
        if (index < _tabControl.TabCount - 1)
            do
            {
                SwapTabPages(tabpage, (_tabControl.TabPages[_tabControl.TabPages.IndexOf(tabpage) - 1]));
            }
            while (_tabControl.TabPages.IndexOf(tabpage) != index);
        _tabControl.SelectedTab = tabpage;
    }

    private void SwapTabPages(TabPage tabpage1, TabPage tabpage2)
    {
        if (_tabControl.TabPages.Contains(tabpage1) == false || _tabControl.TabPages.Contains(tabpage2) == false)
            throw new ArgumentException("TabPages must be in the TabControls TabPageCollection.");

        int Index1 = _tabControl.TabPages.IndexOf(tabpage1);
        int Index2 = _tabControl.TabPages.IndexOf(tabpage2);
        _tabControl.TabPages[Index1] = tabpage2;
        _tabControl.TabPages[Index2] = tabpage1;
    }

    private KeyValuePair<TabPage, int> GetTabPage(TabPage tabpage)
    {
        return _pagesIndexed.Where(p => p.Key == tabpage).First();
    }
}

Answer 5

Como trabajo barato, he usado una etiqueta para tapar las pestañas que quería ocultar.

Luego podemos usar el accesorio visible de la etiqueta como sustituto. Si alguien sigue esta ruta, no te olvides de manejar los trazos del teclado o los eventos de visibilidad. No querría que las teclas de cursor a la izquierda mostraran la pestaña que intenta ocultar.

Answer 6

Crea una nueva clase vacía y pasa esto dentro de ella:

using System.Windows.Forms;

namespace ExtensionMethods
{
    public static class TabPageExtensions
    {

        public static bool IsVisible(this TabPage tabPage)
        {
            if (tabPage.Parent == null)
                return false;
            else if (tabPage.Parent.Contains(tabPage))
                return true;
            else
                return false;
        }

        public static void HidePage(this TabPage tabPage)
        {
            TabControl parent = (TabControl)tabPage.Parent;
            parent.TabPages.Remove(tabPage);
        }

        public static void ShowPageInTabControl(this TabPage tabPage,TabControl parent)
        {
            parent.TabPages.Add(tabPage);
        }
    }
}

2- Agregue referencia al espacio de nombres ExtensionMethods en su código de formulario:

using ExtensionMethods;

3- Ahora puedes usar yourTabPage.IsVisible(); para comprobar su visibilidad, yourTabPage.HidePage(); para ocultarlo, y yourTabPage.ShowPageInTabControl(parentTabControl); para mostrarlo

Answer 7

En WPF, es bastante fácil:

Suponiendo que le ha dado un nombre al TabItem, por ejemplo,

<TabItem Header="Admin" Name="adminTab" Visibility="Hidden">
<!-- tab content -->
</TabItem>

Puede tener lo siguiente en el código detrás del formulario:

 if (user.AccessLevel == AccessLevelEnum.Admin)
 {
     adminTab.Visibility = System.Windows.Visibility.Visible;
 }

Cabe señalar que se ha creado un User nombre de objeto de user con su propiedad AccessLevel establecida en uno de los valores enum definidos por el usuario de AccessLevelEnum ... lo que sea; es solo una condición por la cual decido mostrar la pestaña o no.

Answer 8

Fragmento de código para ocultar un TabPage

private void HideTab1_Click(object sender, EventArgs e)
{
    tabControl1.TabPages.Remove(tabPage1);
}

Fragmento de código para mostrar un TabPage

private void ShowTab1_Click(object sender, EventArgs e)
{
    tabControl1.TabPages.Add(tabPage1);
}

Answer 9

He usado el mismo enfoque, pero el problema es que cuando se quita la página de pestañas de la lista de pestañas de control de pestañas, también se elimina de la lista Controles de la página de pestañas. Y no está dispuesto cuando se elimina la forma.

Por lo tanto, si tiene muchas de estas páginas de pestañas "ocultas", puede hacer que Windows maneje el error de cuota excedida y solo el reinicio de la aplicación lo arreglará.

Answer 10

La propiedad Visiblity no se ha implementado en las Tabpages, y tampoco hay un método Insertar.

Debe insertar y eliminar manualmente las páginas con pestañas.

Aquí hay una solución para lo mismo.

http://www.dotnetspider.com/resources/18344-Hiding-Showing-Tabpages-Tabcontrol.aspx

Answer 11

Las soluciones proporcionadas hasta ahora son demasiado complicadas. Lea la solución más fácil en: http://www.codeproject.com/Questions/614157/How-to-Hide-TabControl-Headers

Puede usar este método para hacerlos invisibles en tiempo de ejecución:

private void HideAllTabsOnTabControl(TabControl theTabControl)
{
  theTabControl.Appearance = TabAppearance.FlatButtons;
  theTabControl.ItemSize = new Size(0, 1);
  theTabControl.SizeMode = TabSizeMode.Fixed;
}

Answer 12

Me doy cuenta de que la pregunta es vieja, y la respuesta aceptada es vieja, pero ...

Al menos en .NET 4.0 ...

Para ocultar una pestaña:

tabControl.TabPages.Remove(tabPage);

Para volver a ponerlo:

tabControl.TabPages.Insert(index, tabPage);

TabPages funciona mucho mejor que los Controls para esto.

Answer 13

No estoy seguro acerca de "Winforms 2.0", pero esto está probado y probado:

http://www.mostthingsweb.com/2011/01/hiding-tab-headers-on-a-tabcontrol-in-c/

Answer 14

No, esto no existe. Debe quitar la pestaña y volver a agregarla cuando lo desee. O use un control de pestaña diferente (de terceros).

Answer 15

Ocultar TabPage y eliminar el encabezado:

this.tabPage1.Hide();
this.tabPage3.Hide();
this.tabPage5.Hide();
tabControl1.TabPages.Remove(tabPage1);
tabControl1.TabPages.Remove(tabPage3);
tabControl1.TabPages.Remove(tabPage5);

Mostrar TabPage y Visible el encabezado:

tabControl1.TabPages.Insert(0,tabPage1);
tabControl1.TabPages.Insert(2, tabPage3);
tabControl1.TabPages.Insert(4, tabPage5);
this.tabPage1.Show();
this.tabPage3.Show();
this.tabPage5.Show();
tabControl1.SelectedTab = tabPage1;

Answer 16

Si está hablando de AjaxTabControlExtender, configure TabIndex de todas las pestañas y establezca la propiedad Visible True / False de acuerdo con sus necesidades.

myTab.Tabs [1] .Visible = verdadero / falso;

Answer 17

También tuve esta pregunta. tabPage.Visible no se implementa como se indicó anteriormente, lo que fue de gran ayuda (+1). Descubrí que puedes anular el control y esto funcionará. Un poco de necroposting, pero pensé en publicar mi solución aquí para otros ...

    [System.ComponentModel.DesignerCategory("Code")]
public class MyTabPage : TabPage
{
    private TabControl _parent;
    private bool _isVisible;
    private int _index;
    public new bool Visible
    {
        get { return _isVisible; }
        set
        {
            if (_parent == null) _parent = this.Parent as TabControl;
            if (_parent == null) return;

            if (_index < 0) _index = _parent.TabPages.IndexOf(this);
            if (value && !_parent.TabPages.Contains(this))
            {
                if (_index > 0) _parent.TabPages.Insert(_index, this);
                else _parent.TabPages.Add(this);
            }
            else if (!value && _parent.TabPages.Contains(this)) _parent.TabPages.Remove(this);

            _isVisible = value;
            base.Visible = value;
        }
    }

    protected override void InitLayout()
    {
        base.InitLayout();
        _parent = Parent as TabControl;
    }
}

Answer 18

puede configurar el elemento primario de la tabulación para anular la ocultación y para mostrar simplemente establecer tabpage principal para la pestaña control

Answer 19

    TabPage pageListe, pageDetay;
    bool isDetay = false;
    private void btnListeDetay_Click(object sender, EventArgs e)
    {
        if (isDetay)
        {
            isDetay = false;
            tc.TabPages.Remove(tpKayit);
            tc.TabPages.Insert(0,pageListe);
        }
        else
        {
            tc.TabPages.Remove(tpListe);
            tc.TabPages.Insert(0,pageDetay);
            isDetay = true;
        }
    }

Answer 20

    public static Action<Func<TabPage, bool>> GetTabHider(this TabControl container) {
        if (container == null) throw new ArgumentNullException("container");

        var orderedCache = new List<TabPage>();
        var orderedEnumerator = container.TabPages.GetEnumerator();
        while (orderedEnumerator.MoveNext()) {
            var current = orderedEnumerator.Current as TabPage;
            if (current != null) {
                orderedCache.Add(current);
            }
        }

        return (Func<TabPage, bool> where) => {
            if (where == null) throw new ArgumentNullException("where");

            container.TabPages.Clear();
            foreach (TabPage page in orderedCache) {
                if (where(page)) {
                    container.TabPages.Add(page);
                }
            }
        };
    }

Úselo así:

    var hider = this.TabContainer1.GetTabHider();
    hider((tab) => tab.Text != "tabPage1");
    hider((tab) => tab.Text != "tabpage2");

El orden original de las pestañas se mantiene en una lista que está completamente oculta dentro de la función anónima. Mantenga una referencia a la instancia de función y conserve su orden de tabulación original.

Answer 21

// inVisible
TabPage page2 = tabControl1.TabPages[0];
page2.Visible= false;

//Visible 
page2.Visible= true;

// disable
TabPage page2 = tabControl1.TabPages[0];
page2.Enabled = false;

// enable
page2.Enabled = true;

//Hide
tabCtrlTagInfo.TabPages(0).Hide()
tabCtrlTagInfo.TabPages(0).Show()

Simplemente copie y pruébelo, el código anterior ha sido probado en vs2010, funciona.

Answer 22

private System.Windows.Forms.TabControl _tabControl;
private System.Windows.Forms.TabPage _tabPage1;
private System.Windows.Forms.TabPage _tabPage2;

...
// Initialise the controls
...

// "hides" tab page 2
_tabControl.TabPages.Remove(_tabPage2);

// "shows" tab page 2
// if the tab control does not contain tabpage2
if (! _tabControl.TabPages.Contains(_tabPage2))
{
    _tabControl.TabPages.Add(_tabPage2);
}