.net barre de défilement automatique problème

Oui, je pense que vous avez déjà diagnostiqué le problème correctement. C'est un sale effet de côté, disons, sur la barre de défilement verticale, apparaissant et ayant besoin d'espace et la disposition des clients de plus petite superficie. Trop petit pour tenir les commandes, maintenant aussi de faire de la barre de défilement horizontale apparaît. Il est en fait bi-stable, la barre horizontale peut scintiller sur et en dehors, dans certains cas.

Pour éviter cet effet, le moteur de disposition aurait à faire plusieurs passages par le biais de la mise en page, de composer avec l'évolution de la zone client. Toutefois, elle ne fait une passe. Qui semble judicieux, cela pourrait être potentiellement sans fin de la boucle. Je ne sais pas d'une vie décente pour résoudre ce problème. Votre utilisateur sera probablement juste redimensionner la fenêtre assez grande pour se débarrasser d'au moins une des barres de défilement.

Je n'ai pas noté exactement le comportement que vous décrivez, mais dans des situations où l'apparence de la barre de défilement verticale rend une barre de défilement horizontale nécessaire.

Vous pouvez définir le contenu du panneau pour permettre à la largeur de la barre de défilement, par exemple si j'ai un ListBox dans un Panel:

listBox1.Width = panel2.Width - System.Windows.Forms.SystemInformation.VerticalScrollBarWidth;

HTH

Alors que c'est une vieille question, c'est toujours un problème .NET 4. Après avoir lu autant que je pouvais trouver sur le sujet, j'ai roulé une combinaison de solutions au sein d'une classe d'aide.

Tout d'abord, voici le résultat que je suis en tournage pour ... j'ai un panneau qui contient une variété de contrôles. Les contrôles enfants, et de leur taille, peuvent changer en fonction de l'activité de l'utilisateur. Je veux que le panneau de redimensionner horizontalement de sorte qu'il n'y a jamais une barre de défilement horizontale, mais si il n'y a pas assez de place à la verticale, je veux que la barre de défilement verticale à apparaître. De plus, la barre de défilement verticale ne peut pas couvrir tout de mon enfant de contrôle quand il s'affiche, et je ne veux pas laisser un vide quand il n'est pas nécessaire.

Les deux 'bugs' qui ma classe helper tente de le résoudre sont d'abord, ne pas afficher la barre de défilement horizontale, et la deuxième, lorsque la barre de défilement verticale apparaît, ont le panneau de la largeur d'augmenter automatiquement à les accueillir.

Mes hypothèses sont que le panneau est fixé pour un redimensionnement automatique et Automatique, et l'enfant contrôles sont définis pour un redimensionnement automatique en tant que bien.

La Solution

La classe helper se fixe sur le panneau (par la manipulation de la Peinture et SizeChanged événements) et fait deux choses. Tout d'abord, il désactive la barre de défilement horizontale. Ce n'est pas aussi facile qu'il y paraît, et j'ai trouvé la solution à ce problème ici Barre de défilement horizontale réponse par Kbv Subrahmanyam. Deuxièmement, en réponse à la Peinture et SizeChanged événements, ainsi que d'un arrière-plan de la minuterie, il vérifie si la propriété Visible de la barre de défilement verticale a changé. Si oui, la classe helper modifie le Droit de la propriété Padding du panneau d'ajouter ou de supprimer de l'espace de la barre de défilement exige. L'utilisation des différentes panneau événements et la minuterie sont nécessaires car .NET expose pas des manifestations à tous pour la barre de défilement (un gros défaut de conception à mon humble avis).

Une fois le dernier point est que vous ne pouvez pas faire quelque chose qui change la taille du panneau lors de la manipulation du SizeChanged événement. Les mauvaises Choses(tm) se produit si vous le faites. Donc, si j'ai besoin de changer le rembourrage en raison d'un SizeChanged cas, je le calendrier de changement pour plus tard.

De toute façon, voici le code pour la classe helper. Il suppose que vous avez tous l '"aide" que les états, dont l'un pour le Système.Le filetage ...

///<summary>
///This class is intended to beat the AutoSize and AutoScroll features into submission!
///
///Or, at least getting them to work the way I want them to (which may not be the way 
///others think they should work).
///
///This class will force a panel that has AutoSize enabled to actually increase its
///width as appropriate when the AutoScroll Vertical scroll bar becomes visible.
///I like this better than attempting to 'reserve' space for the Vertical scroll bar,
///which wastes space when the scroll bar is not needed, and leaves ugly gaps in
///your user interface.
///</summary>
public class AutoScrollFixer
{
///<summary>
///This is the panel we are 'fixing'
///</summary>
private Panel _panel;
///<summary>
///This field keeps track of the original value for
///the right padding property of the panel.
///</summary>
private int _originalRightPadding = 0;
///<summary>
///We use this flag to prevent recursion problems.
///</summary>
private bool _adjusting = false;
///<summary>
///This flag keeps track of the last known state of the scroll bar.
///</summary>
private bool _lastScrollBarVisible = false;
///<summary>
///We use a timer to check the scroll bar state every so often.
///This is necessary since .NET (in another stunning piece of
///architecture from Microsoft) provides absolutely no events
///attached to the scroll bars of a panel.
///</summary>
private System.Windows.Forms.Timer _timer = new System.Windows.Forms.Timer();
///<summary>
///Construct an AutoScrollFixer and attach it to the provided panel.
///Once created, there is no particular reason to keep a reference 
///to the AutoScrollFixer in your code.  It will silently do its thing
///in the background.
///</summary>
///<param name="panel"></param>
public AutoScrollFixer(Panel panel)
{
_panel = panel;
_originalRightPadding = panel.Padding.Right;
EnableVerticalAutoscroll(_panel);
_lastScrollBarVisible = _panel.VerticalScroll.Visible;
_panel.Paint += (s, a) =>
{
AdjustForVerticalScrollbar();
};
_panel.SizeChanged += (s, a) =>
{
//
// We can't do something that changes the size while handling
// a size change.  So, if an adjustment is needed, we will
// schedule it for later.
//
if (_lastScrollBarVisible != _panel.VerticalScroll.Visible)
{
AdjustLater();
}
};
_timer.Tick += (s, a) =>
{
//
// Sadly, the combination of the Paint event and the SizeChanged event
// is NOT enough to guarantee that we will catch a change in the
// scroll bar status.  So, as a last ditch effort, we will check
// for a status change every 500 mSecs.  Yup, this is a hack!
//
AdjustForVerticalScrollbar();
};
_timer.Interval = 500;
_timer.Start();
}
///<summary>
///Enables AutoScroll, but without the Horizontal Scroll bar.
///Only the Vertical Scroll bar will become visible when necessary
///
///This method is based on this StackOverflow answer ...
///https://stackoverflow.com/a/28583501/2175233
///</summary>
///<param name="panel"></param>
public static void EnableVerticalAutoscroll( Panel panel )
{
panel.AutoScroll = false;
panel.HorizontalScroll.Enabled = false;
panel.HorizontalScroll.Visible = false;
panel.HorizontalScroll.Maximum = 0;
panel.AutoScroll = true;
}
///<summary>
///Queue AdjustForVerticalScrollbar to run on the GUI thread after the current
///event has been handled.
///</summary>
private void AdjustLater()
{
ThreadPool.QueueUserWorkItem((t) => 
{
Thread.Sleep(200);
_panel.BeginInvoke((Action)(() =>
{
AdjustForVerticalScrollbar();
}));
});
}
///<summary>
///This is where the real work gets done.  When this method is called, we will
///simply set the right side padding on the panel to make room for the
///scroll bar if it is being displayed, or reset the padding value to 
///its original value if not.
///</summary>
private void AdjustForVerticalScrollbar()
{
if (!_adjusting)
{
try
{
_adjusting = true;
if (_lastScrollBarVisible != _panel.VerticalScroll.Visible)
{
_lastScrollBarVisible = _panel.VerticalScroll.Visible;
Padding p = _panel.Padding;
p.Right = _lastScrollBarVisible ? _originalRightPadding + System.Windows.Forms.SystemInformation.VerticalScrollBarWidth + 2 : _originalRightPadding;
_panel.Padding = p;
_panel.PerformLayout();
}
}
finally
{
_adjusting = false;
}
}
}
}