TabControl ohne Reiter

    • VB.NET

    Es gibt 16 Antworten in diesem Thema. Der letzte Beitrag () ist von FormFollowsFunction.

      TabControl ohne Reiter

      Hier wie man die Reiter eines TabControls verstecken kann, weil manche finden die häßlich.
      Damit kann man Funktionsbereiche einer Anwendung auf verschiedene Tabs unterbringen, und etwa über ein menü oder über eine Combo-/List-Box steuern, welcher Funktionsbereich grade aktiv sein soll.

      Ich hab gleich alle 3 genannten Steuerungs-möglichkeiten implementiert, wie man sieht, macht die Steuerung per Menü etwas mehr Aufwand, da man kein Databinding anwenden kann.

      VB.NET-Quellcode

      1. Public Class frmOhneReiter
      3. Private Sub frmOhneReiter_Load(ByVal sender As Object, ByVal e As EventArgs) _
      4. Handles Me.Load
      5. tabControl1.SuspendLayout()
      6. 'um Reiter zu verbergen benötigt man die 3 folgenden Einstellungen
      7. 'ich empfehle das codeseitig zu machen, weil im Designer hat man sonst
      8. ' Probleme, die TabPages zum designen auszuwählen
      9. tabControl1.SizeMode = TabSizeMode.Fixed
      10. tabControl1.ItemSize = New Size(0, 1)
      11. tabControl1.Appearance = TabAppearance.Buttons
      12. tabControl1.ResumeLayout()
      13. 'list-/Combo-Box konfigurieren
      14. Dim pages = tabControl1.TabPages
      15. Me.listBox1.DisplayMember = "Text"
      16. Me.ComboBox1.DisplayMember = "Text"
      17. listBox1.DataSource = pages
      18. ComboBox1.DataSource = pages
      19. 'MenuItems erzeugen und konfigurieren
      20. Dim tabMenuItems = TabPageToolStripMenuItem.DropDownItems
      21. For Each tp As TabPage In pages
      22. Dim itm = DirectCast(tabMenuItems.Add(tp.Text), ToolStripMenuItem)
      23. AddHandler itm.Click, AddressOf MenuItem_Click
      24. Next
      25. DirectCast(tabMenuItems(0), ToolStripMenuItem).Checked = True
      26. End Sub
      28. Private Sub listControl_SelectedIndexChanged(ByVal sender As Object, ByVal e As EventArgs) _
      29. Handles listBox1.SelectedIndexChanged, ComboBox1.SelectedIndexChanged
      30. tabControl1.SelectedIndex = listBox1.SelectedIndex
      31. 'TabControl ist bisserl doof - es nimmt den Focus, auch wenn nur per Code selektiert wurde
      32. listBox1.Focus() 'Focus zurück zur Listbox
      33. End Sub
      35. Private Sub MenuItem_Click(ByVal sender As Object, ByVal e As EventArgs)
      36. Dim tabMenuItems = TabPageToolStripMenuItem.DropDownItems
      37. For i = 0 To tabMenuItems.Count - 1
      38. Dim itm = DirectCast(tabMenuItems(i), ToolStripMenuItem)
      39. Dim isSelected = itm Is sender
      40. itm.Checked = isSelected
      41. If isSelected Then tabControl1.SelectedIndex = i
      42. Next
      43. End Sub
      45. End Class


      Erläuterung
      Für List- und Combo-Box wird im Load jeweils DataSource und DisplayMember festgelegt, und im listControl_SelectedIndexChanged wird ihr SelectedIndex aufs TabControl übertragen.
      Die MenüItem müssen erst codeseitig erzeugt, und per AddHandler ans MenuItem_Click angeschlossen werden.
      In MenuItem_Click muß der Index für den gewünschten TabIndex erst ermittelt werden, und auch die Checked-Property aller Items korrekt gesetz wern - naja - auch kein Act.

      Man muß sich halt für eine Steuerung entscheiden, weil so, wies hier gemacht ist, erfolgt keine Synchronisation der Listbox, wenn per Menü die Tab gewechselt wurde. Und umgekehrt auch nicht.

      Weitere Ideen, ein TabControl zu pimpen, finden sich auf erweitertes TabControl
      Dateien

      • OhneReiter00.zip

        (14,32 kB, 888 mal heruntergeladen, zuletzt: )

      TabControl ohne Reiter

      [OffTopic]
      Jetzt hatte ich doch glatt den Überblick verloren, und meinen eigenen Tipp nicht wiedergefunden, und daher neu gemacht.
      Ich hab aber nicht einfach einen löschen lassen, sondern hier zusammenführen (Dank an die Mods! :)).
      Weil die neue Variante zeigt auch die Ansteuerung der Tabs mittels "Next"/"Previous" - Buttons, welche auf den Tabs aufsitzen (Assistenten-Navigation).

      Also hier eiglich dasselbe wie oben, nochmal:
      [/OffTopic]

      Mittm TabControl kann man die Funktionalität einer komplexen Anwendung in sinnvolle übersichtliche Einheiten strukturieren, ohne dass man viele Dialoge aufpoppen lassen müsste.

      Gelegentlich will man sich aber auch sowas wie einen Assistenten basteln, also eine Anwendung, die eine Ansicht nach der anneren nacheinander präsentiert, und wo man vor- und zurück-navigieren kann - Assistenten-Navigation.

      Oder man hat eine Treeview oder Listbox, und je nach angewähltem Item benötigt man eine annere Ansicht - Frameset-Navigation.

      Auch für diese Anforderungen eignet sich TabControl. Man muß nur die Reiter verstecken, dann hat man damit ein Dingsbums mit vielen Panels, die man nach Belieben nach vorne holen kann (.SelectedIndex setzen oder .SelectedTab)
      Dabei erhält man sogar den Komfort, dass die Reiter nur zur Laufzeit verschwinden - zum Designen kann man ganz normal zwischen den Tabs wechseln, und seine Controls aufbringen.

      Anbei ein Sample, was die genannten 3 Möglichkeiten der Navigation aufzeigt:
      1. standard-Navigation mittels der Reiter
      2. versteckte Reiter - Assistenten-Navigation durch Vor- und Zurück-Buttons
      3. versteckte Reiter - Frameset-Navigation über Anwahl von Listbox-Items

      VB.NET-Quellcode

      1. Public Class frmOhneReiter
      3. Private Sub frmOhneReiter_Load(ByVal sender As Object, ByVal e As EventArgs) _
      4. Handles MyBase.Load
      5. lstFramesetNavi.DataSource = TabControl2.TabPages.Cast(Of TabPage)().ToList
      6. lstFramesetNavi.DisplayMember = "Text"
      7. For Each tc In {TabControl2, TabControl3}
      8. With tc
      9. .SuspendLayout()
      10. 'diese 3 Einstellungen verstecken die Reiter erst zur Laufzeit
      11. 'bei Design-Arbeiten am Form sind die Reiter ja sehr nützlich
      12. .SizeMode = TabSizeMode.Fixed
      13. .ItemSize = New Size(0, 1)
      14. .Appearance = TabAppearance.Buttons
      15. .ResumeLayout()
      16. End With
      17. Next
      18. End Sub
      20. Private Sub WizzardNaviButton_Click(ByVal sender As Object, ByVal e As EventArgs) _
      21. Handles btNext6.Click, btPrev7.Click, btNext7.Click, btPrev8.Click
      22. Select Case True
      23. Case sender Is btNext6, sender Is btNext7
      24. TabControl3.SelectedIndex += 1
      25. Case sender Is btPrev7, sender Is btPrev8
      26. TabControl3.SelectedIndex -= 1
      27. End Select
      28. End Sub
      30. Private Sub lstFramesetNavi_SelectedIndexChanged(ByVal sender As Object, ByVal e As EventArgs) _
      31. Handles lstFramesetNavi.SelectedIndexChanged
      32. TabControl2.SelectedIndex = lstFramesetNavi.SelectedIndex
      33. End Sub
      35. End Class
      Dateien

      • OhneReiter00.zip

        (15,04 kB, 605 mal heruntergeladen, zuletzt: )

      Dieser Beitrag wurde bereits 6 mal editiert, zuletzt von „ErfinderDesRades“ ()

      TreeviewFrameset

      Hier noch eine Variante, wo die Tabs nicht per Menü, Combo oder Listbox gesteuert werden, sondern über einen Treeview. Das mag angezeigt sein bei extrem vielen TabPages, welche man in sinnvolle Gruppen gruppieren möchte.
      Zu beachten, dass die Gruppen-Treenodes keiner TabPage zugeordnet sind, sondern nur diejenigen Nodes addressieren einen Tab, welche keine Childnodes haben ("Blätter").
      Ich hab einen Spezial-Treeview dafür gecodet, der eine "TabControl"-Property aufweist. Dieser Property kann man im Designer ein TabControl zuweisen, und noch im Designer überträgt der Treeview seine Knoten-Beschriftungen auf die Tabs des TabControls.

      Zur Designzeit kann der Treeview natürlich keine Tabs auswählen, und deshalb werden die Beschriftungen übertragen.
      Man gestaltet also die Treenodes im Designer, und wirft einen Haufen Tabpages ins Tabcontrol. Indem man dann (immer noch im Designer) die TabControl-Property des Treeviews festlegt, setzt man dadurch die Tab-Beschriftungen, anhand derer man sich bei der Gestaltung der Tabpages orientieren kann.
      Bei der Zuordnung ist allein die Reihenfolge der Tabpages maßgeblich. Ändert man die Reihenfolge, so bügelt der Treeview seine Beschriftungen gnadenlos drüber, sodass u.U. mehrere Beschriftungen gleichzeitig geändert werden.
      Eine Neu-Beschriftung löst man aus, indem man die FramesetTreeview.Tabcontrol-Property auf "(keine)" setzt, und dann wieder aufs Tabcontrol.
      Es wären auch ganz annere Konzepte von Zuordnung denkbar gewesen: Etwa dass man die Zuordnungen in einer gesonderten Datei festlegt. Oder dass man Zuordnungs-Informationen in die Tag-Property der TabPages schreibt.
      Aber sowas wäre mit Sicherheit wesentlich umständlicher zu benutzen als meine Lösung, wo man einfach den Treeview-Editor des VisualStudios verwenden kann, um die Struktur zu organisieren.
      Also das Ergebnis zur Laufzeit ist nicht sonderlich berühmt, aber man kann erkennen, das die richtige Tabpage selectiert wurde.

      Bitte viel testen, weil bei der Entwicklung von Controls finde ich das Designer-Verhalten immer sehr unkalkulierbar. ZB der FramesetTreeview ist davon abhängig, dass der Designer-Code zuerst die Treenodes generiert, und danach die TabControl-Zuweisung. Das scheint zwar hinzuhauen, aber vlt. sind ja auch Konstellationen möglich, wo die Treenodes erst hinterher geadded werden - ich weiß es nicht.

      FramesetTreeview-Code

      VB.NET-Quellcode

      1. Imports System.ComponentModel
      3. <DesignerCategory("code")> _
      4. Public Class FramesetTreeView : Inherits TreeView
      5. Private _TabControl As TabControl
      6. Public Property TabControl As TabControl
      7. Get
      8. Return _TabControl
      9. End Get
      10. Set(value As TabControl)
      11. _TabControl = value
      12. If _TabControl Is Nothing Then Return
      13. If Not DesignMode Then Return
      14. 'im Designmode wird der Treeview rekursiv durchlaufen, und den tabs wird die Beschriftung derjenigen Nodes zugewiesen, die keine ChildNodes haben
      15. Dim i = 0
      16. Dim tabs = _TabControl.TabPages
      17. Dim recurse As Action(Of TreeNodeCollection) = Sub(nodes As TreeNodeCollection)
      18. For Each nd As TreeNode In nodes
      19. If i >= tabs.Count Then Return
      20. If nd.Nodes.Count = 0 Then
      21. tabs(i).Text = nd.Text
      22. i += 1
      23. Else
      24. recurse(nd.Nodes)
      25. End If
      26. Next
      27. End Sub
      28. recurse(Nodes)
      29. For i = i To tabs.Count - 1
      30. tabs(i).Text = tabs(i).Name
      31. Next
      32. End Set
      33. End Property
      35. Protected Overrides Sub OnAfterSelect(e As System.Windows.Forms.TreeViewEventArgs)
      36. If e.Node.Nodes.Count = 0 Then
      37. Dim count = 0
      38. Dim done = False
      39. 'rekursiv wird der SelectedNode gesucht - dabei werden die Nodes ohne Childnodes gezählt.
      40. Dim recurse As Action(Of TreeNodeCollection) = Sub(nodes As TreeNodeCollection)
      41. For Each nd As TreeNode In nodes
      42. If done Then Return
      43. If nd.Nodes.Count = 0 Then
      44. If nd Is e.Node Then
      45. done = True
      46. Return
      47. End If
      48. count += 1
      49. Else
      50. recurse(nd.Nodes)
      51. End If
      52. Next
      53. End Sub
      54. recurse(Nodes)
      55. _TabControl.SelectedIndex = count 'count ist der Index des assoziierten tabs
      56. Me.Focus()
      57. End If
      58. MyBase.OnAfterSelect(e)
      59. End Sub
      60. End Class


      Hinweis zum Download:
      Der Designer kann das Form erst darstellen, nachdem die Solution kompiliert wurde (Menü - "Erstellen" - "Projektmappe neu erstellen")
      Oder einfach F5 drücken.
      Dateien

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „ErfinderDesRades“ ()

      Hallo,

      ich habe da mal ne Frage/Antwort.
      Wäre es nicht einfacher sich einfach ein eigenes UserControl/Control zu kompilieren bzw. eine Klasse zu erstellen, die von TabControl erbt?

      Sähe dann so aus:

      VB.NET-Quellcode

      1. Friend Class TablessTabControl
      2. Inherits TabControl
      3. Private Const TCM_ADJUSTRECT As Integer = &H1328
      5. Protected Overrides Sub WndProc(ByRef m As Message)
      6. ' Hide the tab headers at run-time
      7. If m.Msg = TCM_ADJUSTRECT AndAlso Not DesignMode Then
      8. m.Result = DirectCast(1, IntPtr)
      9. Return
      10. End If
      12. ' call the base class implementation
      13. MyBase.WndProc(m)
      14. End Sub
      15. End Class


      bzw.

      C#-Quellcode

      1. internal class TablessTabControl : TabControl
      2. {
      3. private const int TCM_ADJUSTRECT = 0x1328;
      5. protected override void WndProc(ref Message m)
      6. {
      7. // Hide the tab headers at run-time
      8. if (m.Msg == TCM_ADJUSTRECT && !DesignMode)
      9. {
      10. m.Result = (IntPtr)1;
      11. return;
      12. }
      14. // call the base class implementation
      15. base.WndProc(ref m);
      16. }
      17. }


      Dazu müsste man nur eine Klasse hinzufügen und den Code einfügen, dann das Projekt erstellen/debuggen, aus der Toolbox auf die Form ziehen und zack, ein neues TabControl ohne Tabs. Ein Vorteil ist hierbei, dass diese nur zur Laufzeit ausgeblendet werden, im Designer ist alles aktiv.

      Grüße
      #define for for(int z=0;z<2;++z)for // Have fun!
      Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

      Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

      Sorry, ich hatte das mal vor längerer Zeit für mein Projekt von Stackoverflow übernommen und habe es jetzt deshalb so angegeben.
      Deshalb ist es ja auch frei zur Verfügung, aber ok, wenn jemand die Source haben will ;)
      #define for for(int z=0;z<2;++z)for // Have fun!
      Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

      Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

      Wäre es nicht einfacher sich einfach ein eigenes UserControl/Control zu kompilieren bzw. eine Klasse zu erstellen, die von TabControl erbt?
      Einfacher ists nicht, weil man braucht eine Extra-Klasse, wo ich nur 4 Zeilen brauche, die ich zB auch als Tabcontrol-Extension formulieren könnte, und dann wäre Tablessness ein Feature jedes' Tabcontrols :P .

      Aber was mir an dem Teil gefällt, ist, dass der Rand drumrum schmaler ist.
      Der ist bei meinem Ansatz ziemlich breit, und ist meist nicht erwünscht, aber afaik nicht wegzukriegen.

      @Trade : Kurze Frage, gibts zufällig auch ne WindowsMessage um diese kleine scrollbar auszubelenden die auftaucht wenn man viele TabPages hat:

      Unnötiges Vollzitat entfernt
      -Artentus
      C# Developer
      Learning C++

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Artentus“ ()

      Moin,

      das Problem hatte ich auch schon, bisher aber noch keine Lösung gefunden, weil das TabControl hierfür nicht flexibel genug ist.
      Sollte jemand eine Lösung haben, wäre es toll, wenn er sie hier mit uns teilen könnte. ;)

      Grüße
      #define for for(int z=0;z<2;++z)for // Have fun!
      Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

      Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

      @Rikudo
      @Trade
      Ganz einfach weg bekommen kann man sie soweit ich weiß nicht, man kann jedoch die Tabs auf mehrere Zeilen aufteilen, indem man ​TCS_MULTILINE setzt.

      Und wenn wir schon grad bei sonstigem TabControl-Zeugs sind:
      Mit ​TCS_RIGHTJUSTIFY sorgt man dafür, dass sich die Tab-Header auf die komplette Breite erstrecken - finde den Effekt ganz nett.

      Tabcontrol mit Reiter - einzelne TabPages verstecken

      @RodFromGermany behauptet hier, einen Weg dafür gefunden zu haben: nämlich die TabPageCollection leeren, dann aber die TabPages, die man behalten will, wieder hinmachen:

      RodFromGermany schrieb:

      @ErfinderDesRades Jetzt hab ich es gefunden:

      C#-Quellcode

      1. this.tabControl1.TabPages.Clear(); // leert nur die Collection, die TabPages bleiben erhalten
      2. this.tabControl1.TabPages.Add(this.tc1); // die Collection mit den erforderlichen Pages neu aufbauem
      3. this.tabControl1.TabPages.Add(this.tc3);
      4. this.tabControl1.TabPages.Add(this.tc5);

      (Ich übernehme das (erstmal ungeprüft) hierher, damit ich's bei Bedarf wiederfinde)

      Ich hab das hier in meinen DLLs drinne. Funktioniert auch.

      VB.NET-Quellcode

      1. Private Class TabPageSettings
      2. Public TabPage As TabPage = Nothing
      3. Public ContainingTabControl As TabControl = Nothing
      4. End Class
      6. Private ReadOnly ListOfTabPages As New List(Of TabPageSettings)
      8. <Extension> Public Sub ShowTab(TabPage As TabPage)
      9. Dim FittingTabPageSettings = ListOfTabPages.FirstOrDefault(Function(x) x.TabPage Is TabPage)
      10. If FittingTabPageSettings IsNot Nothing AndAlso Not FittingTabPageSettings.ContainingTabControl.TabPages.Contains(TabPage) Then FittingTabPageSettings.ContainingTabControl.TabPages.Add(TabPage)
      11. End Sub
      13. <Extension> Public Sub HideTab(TabPage As TabPage)
      14. If TabPage.Parent Is Nothing Then Return
      15. Dim TabControl = DirectCast(TabPage.Parent, TabControl)
      16. If Not TabControl.TabPages.Contains(TabPage) Then Return
      17. TabControl.TabPages.Remove(TabPage)
      18. ListOfTabPages.Add(New TabPageSettings With {.ContainingTabControl = TabControl, .TabPage = TabPage})
      19. End Sub


      ##########

      eigene Extensions durch .NET-Varianten ersetzt
      Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

      Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VaporiZed“ ()

      Da ich selber mal wieder ein TabControl zur Hand nehme und über das Problem gestolpert bin, dass man die TabPages auch bei einem TabControl ohne Reiter mit Strg+BildAuf/Strg+BildAb/Strg+Tab wechseln kann, obwohl das vom Programmierer wahrscheinlich nicht gewollt ist, hab ich grad festgestellt, dass das mit meinen Extensions gut zu lösen ist. Man stellt das TabControl mithilfe der von EdR genannten Einstellungen auf reiterlos, versteckt alle TabPages mithilfe der im Vorpost genannten HideTab-Extension bis auf die einzige anzuzeigende Page und zeigt dann im Programmverlauf z.B. mit Buttons die TabPage an, die man sehen will und versteckt alle anderen.
      Das Projekt im Anhang ist etwas ausgebaut, damit man nicht alle Pages einzeln toggeln muss.
      Dateien
      Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

      Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

      @VaporiZed Ich hab mal reingeschaut.
      Wenn Du Dir über die TabPage deren Parent holst und das alles (TabControl und TabPages) in Klassenvariablen speicherst, wäre es nicht einfacher, dafür eine von TabPage abgeleitete Klasse zu schreiben?
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

      Das ist richtig, aber ich belasse Controls meistens gerne so, wie sie sind. Der eine so, der andere so. Aber es spräche nix dagegen, eine dementsprechende Klasse zu generieren.
      Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

      Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

      Hier mal beide Lösungen in einem Projekt, Umschaltung durch Auswahl der Startform in den Projekteigenschaften.
      TabControl ohne Reiter und Navigationsumgebung2.zip
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

      Hier noch eine Variante:
      Die Navigationsumgebung fange ich im KeyDown Ereignis ab, finde ich eleganter als an der TabPageCollection rum zu fummeln.
      Und weil ich schonmal da war, habe ich noch ein paar Methoden zu selektieren eingebaut.

      VB.NET-Quellcode

      1. Public Class TabControlEx
      2. Inherits TabControl
      4. Sub New()
      5. DisableNavigationKeys = True
      6. End Sub
      8. #Region "Hide Tab's At Runtime"
      10. Private Const TCM_ADJUSTRECT As Integer = &H1328
      12. Protected Overrides Sub WndProc(ByRef m As Message)
      13. If Not DesignMode AndAlso m.Msg = TCM_ADJUSTRECT Then
      14. m.Result = CType(1, IntPtr)
      15. Return
      16. End If
      17. MyBase.WndProc(m)
      18. End Sub
      20. #End Region
      22. #Region "Disable Control Navigation Logig"
      24. Private _DisableNavigationKeys As Boolean
      25. Public Property DisableNavigationKeys() As Boolean
      26. Get
      27. Return _DisableNavigationKeys
      28. End Get
      29. Set(value As Boolean)
      30. _DisableNavigationKeys = value
      31. Select Case _DisableNavigationKeys
      32. Case True
      33. RemoveHandler KeyDown, AddressOf Me_KeyDown
      34. AddHandler KeyDown, AddressOf Me_KeyDown
      35. Case False
      36. RemoveHandler KeyDown, AddressOf Me_KeyDown
      37. End Select
      38. End Set
      39. End Property
      41. Private Sub Me_KeyDown(sender As Object, e As KeyEventArgs)
      42. e.SuppressKeyPress =
      43. e.KeyCode = Keys.Left OrElse
      44. e.KeyCode = Keys.Right
      45. End Sub
      47. #End Region
      49. #Region "Custom Navigation"
      51. Public Sub SelectNextTabPage()
      52. Dim selectedTabIndex As Integer = TabPages.IndexOf(SelectedTab)
      53. If selectedTabIndex = TabPages.Count - 1 Then
      54. selectedTabIndex = 0
      55. Else
      56. selectedTabIndex = selectedTabIndex + 1
      57. End If
      58. SelectedTab = TabPages(selectedTabIndex)
      59. End Sub
      61. Public Sub SelectBeforeTabPage()
      62. Dim selectedTabIndex As Integer = TabPages.IndexOf(SelectedTab)
      63. If selectedTabIndex = 0 Then
      64. selectedTabIndex = TabPages.Count - 1
      65. Else
      66. selectedTabIndex = selectedTabIndex - 1
      67. End If
      68. SelectedTab = TabPages(selectedTabIndex)
      69. End Sub
      71. Public Sub SelectFirstTabPage()
      72. SelectedTab = TabPages(0)
      73. End Sub
      75. Public Sub SelectLastTabPage()
      76. SelectedTab = TabPages(TabPages.Count - 1)
      77. End Sub
      79. #End Region
      81. End Class
      Dateien