Comment cacher TabPage de TabControl [dupliquer]
cette question a déjà une réponse ici:
- cacher et afficher des onglets dans tabControl 16 réponses
22 réponses
Non, ça n'existe pas. Vous devez supprimer l'onglet et ajouter de nouveau quand vous le voulez. Ou utilisez un contrôle différent (tiers) onglet.
Extrait de Code pour Cacher un élément tabpage
private void HideTab1_Click(object sender, EventArgs e)
{
tabControl1.TabPages.Remove(tabPage1);
}
Extrait de Code pour Montrer un élément tabpage
private void ShowTab1_Click(object sender, EventArgs e)
{
tabControl1.TabPages.Add(tabPage1);
}
Visiblity n'a pas été implémentée sur les onglets, et il n'y a pas non plus de méthode Insert.
vous devez insérer et supprimer manuellement les pages d'onglets.
voici un travail pour le même.
http://www.dotnetspider.com/resources/18344-Hiding-Showing-Tabpages-Tabcontrol.aspx
je me rends compte que la question Est ancienne, et la réponse acceptée est ancienne, mais ...
au moins dans .NET 4.0 ...
Pour masquer un onglet:
tabControl.TabPages.Remove(tabPage);
à remettre À sa place:
tabControl.TabPages.Insert(index, tabPage);
TabPages fonctionne tellement mieux que Controls pour cela.
variante 1
afin d'éviter le klikering visuel, vous pourriez avoir besoin d'utiliser:
bindingSource.RaiseListChangeEvent = false
ou
myTabControl.RaiseSelectedIndexChanged = false
supprimer une page d'onglet:
myTabControl.Remove(myTabPage);
Ajouter un onglet page:
myTabControl.Add(myTabPage);
insérer une page d'onglet à un endroit précis:
myTabControl.Insert(2, myTabPage);
Ne pas oublier de revers les changements:
bindingSource.RaiseListChangeEvent = true;
ou
myTabControl.RaiseSelectedIndexChanged = true;
variante 2
myTabPage.parent = null;
myTabPage.parent = myTabControl;
les Solutions proposées jusqu'à présent sont beaucoup trop compliquées. Lire la solution la plus facile à: http://www.codeproject.com/Questions/614157/How-to-Hide-TabControl-Headers
vous pouvez utiliser cette méthode pour les rendre invisibles à l'exécution:
private void HideAllTabsOnTabControl(TabControl theTabControl)
{
theTabControl.Appearance = TabAppearance.FlatButtons;
theTabControl.ItemSize = new Size(0, 1);
theTabControl.SizeMode = TabSizeMode.Fixed;
}
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éer une nouvelle classe vide et passer à l'intérieur de celui-ci:
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-Ajouter une référence à L'espace de nom ExtensionMethods dans votre code de formulaire:
using ExtensionMethods;
3 - Maintenant, vous pouvez utiliser yourTabPage.IsVisible(); pour vérifier sa visibilité, yourTabPage.HidePage(); pour le cacher, et yourTabPage.ShowPageInTabControl(parentTabControl); pour l'afficher.
j'ai combiné la réponse de @Jack Griffin et celle de @amazedsaint ( le code dotnetspider snippet respectivement ) en un seul TabControlHelper .
le TabControlHelper vous permet:
- Afficher / cacher toutes les pages d'onglet
- Afficher / Cacher les pages de l'onglet simple
- conserver la position originale des pages de l'onglet
- Swap onglet pages
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();
}
}
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 initial des onglets est conservé dans une liste qui est complètement cachée à l'intérieur de la fonction anonymous. Conservez une référence à l'instance de la fonction et vous conservez votre commande d'onglet originale.
vous pouvez définir le parent de l'onglet à null pour cacher et pour afficher juste mettre le parent de tabpage sur le tabcontrol
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 tabcontrol.
par exemple: La ligne suivante ajoute un onglet nommé "readformatcardpage" à un Tabcontrol nommé "tabcontrol"
this.tabcontrol.Contrôle.Ajouter(ce.readformatcardpage);
ce qui suit empêchera l'ajout de l'onglet tabcontrol
//ce.tabcontrol.Contrôle.Ajouter(ce.readformatcardpage);
+1 pour microsoft :-) .
J'ai réussi à le faire de cette façon :
( il suppose que vous avez un bouton 'Next' qui affiche le prochain tabpage-tabSteps est le nom du contrôle de L'onglet)
Au démarrage, enregistrez toutes les pages tabulées dans une liste appropriée .
Lorsque l'utilisateur appuie sur le bouton Suivant, supprimer tous les onglets dans le contrôle de l'onglet, puis
ajouter ce qui suit 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);
}
}
comme un travail bon marché autour, j'ai utilisé une étiquette pour couvrir les onglets que je voulais cacher.
nous pouvons alors utiliser la prop visible de l'étiquette comme un substitut. Si quelqu'un emprunte cette voie, n'oubliez pas de gérer les touches du clavier ou les événements de visibilité. Vous ne voudriez pas que les touches du curseur droit gauche exposent l'onglet que vous essayez de cacher.
pas sûr de "Winforms 2.0" mais cela est essayé et prouvé:
http://www.mostthingsweb.com/2011/01/hiding-tab-headers-on-a-tabcontrol-in-c /
dans WPF, c'est assez facile:
en supposant que vous avez donné un nom au TabItem, par exemple,
<TabItem Header="Admin" Name="adminTab" Visibility="Hidden">
<!-- tab content -->
</TabItem>
vous pouvez avoir ce qui suit dans le code derrière le formulaire:
if (user.AccessLevel == AccessLevelEnum.Admin)
{
adminTab.Visibility = System.Windows.Visibility.Visible;
}
il est à noter qu'un objet User nommé user a été créé avec sa propriété AccessLevel fixée à l'une des valeurs enum définies par l'utilisateur de AccessLevelEnum ... peu importe, c'est juste une condition par laquelle je décide de montrer le onglet ou pas.
j'ai aussi eu cette question. objet tabpage.Visible n'est pas implémenté comme indiqué précédemment, ce qui a été d'une grande aide (+1). J'ai trouvé que vous pouvez annuler la commande et ça va marcher. Un peu de nécroposage, 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;
}
}
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;
}
}
j'ai utilisé la même approche, mais le problème est que lorsque la page tab a été retirée de la liste tabpages de Contrôle tab, elle est également retirée de la liste tab page Controls. Et il n'est pas disposé quand le formulaire est disposé.
donc si vous avez un grand nombre de ces pages d'onglet" cachés", vous pouvez Get Windows handle quota exceeded error et seul le redémarrage de l'application le corrigera.
si vous parlez D'AjaxTabControlExtender puis mettez TabIndex de chaque onglets et mettez propriété Visible True/False selon votre besoin.
myTab.Tabs[1].Visible=vrai/ faux;
// 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()
il suffit de copier coller et essayer,le code ci-dessus a été testé dans vs2010, il fonctionne.
Hide TabPage et supprimer l'en-tête:
this.tabPage1.Hide();
this.tabPage3.Hide();
this.tabPage5.Hide();
tabControl1.TabPages.Remove(tabPage1);
tabControl1.TabPages.Remove(tabPage3);
tabControl1.TabPages.Remove(tabPage5);
afficher L'onglet et afficher L'en-tête:
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;