Non, ça n'existe pas. Vous devez supprimer l'onglet et l'ajouter à nouveau lorsque vous le souhaitez. Ou utilisez un autre contrôle d'onglet (tiers).
Extrait de code permettant de masquer une tabPage
private void HideTab1_Click(object sender, EventArgs e)
{
tabControl1.TabPages.Remove(tabPage1);
}
Extrait de code pour l'affichage d'une page de tabulation
private void ShowTab1_Click(object sender, EventArgs e)
{
tabControl1.TabPages.Add(tabPage1);
}
Je réalise que la question est ancienne et que la réponse acceptée est ancienne, mais ...
Au moins dans .NET 4.0 ...
Pour masquer un onglet:
tabControl.TabPages.Remove(tabPage);
Pour le remettre:
tabControl.TabPages.Insert(index, tabPage);
TabPages fonctionne tellement mieux que Controls pour cela.
La propriété Visiblity n'a pas été implémentée dans les pages à onglets et il n'y a pas non plus de méthode Insert.
Vous devez manuellement insérer et supprimer des pages à onglet.
Voici un travail autour de la même chose.
http://www.dotnetspider.com/resources/18344-Hiding-Showing-Tabpages-Tabcontrol.aspx
Variante 1
Afin d'éviter le klikering visuel, vous devrez peut-être utiliser:
bindingSource.RaiseListChangeEvent = false
ou
myTabControl.RaiseSelectedIndexChanged = false
Supprimer une page à onglet:
myTabControl.Remove(myTabPage);
Ajouter une page à onglet:
myTabControl.Add(myTabPage);
Insérer une page à onglet à un emplacement spécifique:
myTabControl.Insert(2, myTabPage);
N'oubliez pas d'inverser les changements:
bindingSource.RaiseListChangeEvent = true;
ou
myTabControl.RaiseSelectedIndexChanged = true;
Variante 2
myTabPage.parent = null;
myTabPage.parent = myTabControl;
Les solutions fournies jusqu'à présent sont beaucoup trop compliquées. Lisez la solution la plus simple à l'adresse suivante: http://www.codeproject.com/Questions/614157/How-to-Hide-TabControl-Headers
Vous pouvez utiliser cette méthode pour les rendre invisibles au moment de l'exécution:
private void HideAllTabsOnTabControl(TabControl theTabControl)
{
theTabControl.Appearance = TabAppearance.FlatButtons;
theTabControl.ItemSize = new Size(0, 1);
theTabControl.SizeMode = TabSizeMode.Fixed;
}
J'ai combiné la réponse de @Jack Griffin et celle de @amazedsaint ( l'extrait de code de dotnetspider, respectivement ) en un seul TabControlHelper .
Le TabControlHelper vous permet de:
- Afficher/masquer tous les onglets
- Afficher/masquer les pages à onglet unique
- Conserver la position d'origine des pages à onglet
- Permuter les pages à onglet
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();
}
}
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);
}
Créez une nouvelle classe vide et collez-la à l'intérieur:
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- Ajoutez une référence à l'espace de noms ExtensionMethods dans votre code de formulaire:
using ExtensionMethods;
3- Vous pouvez maintenant utiliser yourTabPage.IsVisible(); pour vérifier sa visibilité, yourTabPage.HidePage(); pour le masquer et yourTabPage.ShowPageInTabControl(parentTabControl); pour le montrer.
vous pouvez définir le parent de la page de tabulation sur null pour le masquer et pour afficher simplement définir parent de page de tabulation sur le contrôle de tabulation
+1 pour Microsoft :-).
J'ai réussi à le faire comme suit:
(cela suppose que vous avez un bouton Next qui affiche le TabPage suivant - tabSteps est le nom du contrôle Tab)
Au démarrage, enregistrez toutes les pages dans une liste appropriée.
Lorsque l'utilisateur appuie sur la touche Next, supprime toutes les TabPages du contrôle Onglet, puis l'ajoute avec l'index approprié:
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();
}
Mise à jour
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);
}
}
Eh bien, si vous ne voulez pas gâcher le code existant et que vous voulez juste cacher un onglet, vous pouvez modifier le code généré par le compilateur pour commenter la ligne qui ajoute l’onglet au contrôle de tabulation.
Par exemple: La ligne suivante ajoute un onglet appelé "readformatcardpage" à un Tabcontrol nommé "tabcontrol".
this.tabcontrol.Controls.Add (this.readformatcardpage);
Ce qui suit empêchera l'ajout de l'onglet à la commande de tabulation
//this.tabcontrol.Controls.Add(this.readformatcardpage);
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);
}
}
};
}
Utilisez-le comme ceci:
var hider = this.TabContainer1.GetTabHider();
hider((tab) => tab.Text != "tabPage1");
hider((tab) => tab.Text != "tabpage2");
L'ordre d'origine des onglets est conservé dans une liste qui est complètement masquée à l'intérieur de la fonction anonyme. Conservez une référence à l'instance de fonction et conservez l'ordre de tabulation d'origine.
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;
}
}
En WPF, c'est assez simple:
En supposant que vous ayez donné un nom à TabItem, par exemple,
<TabItem Header="Admin" Name="adminTab" Visibility="Hidden">
<!-- tab content -->
</TabItem>
Vous pourriez avoir ce qui suit dans le code derrière le formulaire:
if (user.AccessLevel == AccessLevelEnum.Admin)
{
adminTab.Visibility = System.Windows.Visibility.Visible;
}
Il convient de noter qu'un objet User nommé user a été créé avec sa propriété AccessLevel définie sur l'une des valeurs d'enum définies par l'utilisateur de AccessLevelEnum... c'est juste une condition par laquelle je décide d'afficher l'onglet ou non.
J'ai utilisé la même approche, mais le problème est que, lorsque la page à onglet a été supprimée de la liste TabPages du contrôle d'onglets, elle est également supprimée de la liste Contrôles de la page à onglets. Et il n'est pas éliminé lorsque la forme est éliminée.
Donc, si vous avez beaucoup de telles pages à onglets "cachées", vous pouvez obtenir une erreur dépassant le quota de Windows et seul le redémarrage de l’application résoudra le problème.
Pas sûr de "Winforms 2.0" mais cela a fait ses preuves:
http://www.mostthingsweb.com/2011/01/hiding-tab-headers-on-a-tabcontrol-in-c/
Pour contourner le problème, j'ai utilisé une étiquette pour recouvrir les onglets que je voulais cacher.
Nous pouvons alors utiliser l'accessoire visible de l'étiquette comme substitut. Si quelqu'un se lance dans cette voie, n'oubliez pas de gérer les coups de clavier ou les événements de visibilité. Vous ne voudriez pas que les touches du curseur gauche/droite exposent l'onglet que vous essayez de cacher.
J'ai aussi eu cette question. tabPage.Visible n'est pas implémenté comme indiqué précédemment, ce qui était d'une grande aide (+1). J'ai trouvé que vous pouvez remplacer le contrôle et cela fonctionnera. Un peu de nécropostage, mais j'ai pensé poster ma solution ici pour les autres ...
[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;
}
}
Si vous parlez de AjaxTabControlExtender, définissez TabIndex pour chaque onglet et définissez la propriété Visible True/False en fonction de vos besoins.
myTab.Tabs [1] .Visible = true/false;