Code:
/ FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / WinForms / Managed / System / WinForms / ContainerControl.cs / 3 / ContainerControl.cs
//----------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
namespace System.Windows.Forms {
using System.Threading;
using System.Runtime.InteropServices;
using System.Runtime.Remoting;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System;
using System.Drawing;
using System.ComponentModel.Design;
using System.Windows.Forms.Layout;
using System.Windows.Forms.Internal;
using Microsoft.Win32;
using System.Security;
using System.Security.Permissions;
///
/// Defines a
/// base class for
/// controls that can parent other controls.
///
[ComVisible(true),
ClassInterface(ClassInterfaceType.AutoDispatch)
]
public class ContainerControl : ScrollableControl, IContainerControl {
private Control activeControl; // current active control
private Control focusedControl; // Current focused control. Do not directly edit this value.
private Control unvalidatedControl; // The last control that requires validation. Do not directly edit this value.
private AutoValidate autoValidate = AutoValidate.Inherit; // Indicates whether automatic validation is turned on.
private EventHandler autoValidateChanged; // Event fired whenever the AutoValidate property changes.
// Auto scaling property values
private SizeF autoScaleDimensions = SizeF.Empty;
private SizeF currentAutoScaleDimensions = SizeF.Empty;
private AutoScaleMode autoScaleMode = AutoScaleMode.Inherit;
private BitVector32 state = new BitVector32();
private static readonly int stateScalingNeededOnLayout = BitVector32.CreateMask(); // True if we need to perform scaling when layout resumes
private static readonly int stateValidating = BitVector32.CreateMask(stateScalingNeededOnLayout); // Indicates whether we're currently state[stateValidating].
private static readonly int stateProcessingMnemonic = BitVector32.CreateMask(stateValidating); // Indicates whether we or one of our children is currently processing a mnemonic.
private static readonly int stateScalingChild = BitVector32.CreateMask(stateProcessingMnemonic); // True while we are scaling a child control
private static readonly int stateParentChanged = BitVector32.CreateMask(stateScalingChild); // Flagged when a parent changes so we can adpat our scaling logic to match
private static readonly int PropAxContainer = PropertyStore.CreateKey();
private const string fontMeasureString = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
///
/// Initializes a new instance of the
///
public ContainerControl() : base() {
SetStyle(ControlStyles.AllPaintingInWmPaint, false);
// this class overrides GetPreferredSizeCore, let Control automatically cache the result
SetState2(STATE2_USEPREFERREDSIZECACHE, true);
}
///
/// AutoScaleDimensions represents the DPI or Font setting that the control has been scaled
/// to or designed at. Specifically, at design time this property will be set by the
/// designer to the value that the developer is designing at. Then, at runtime, when the
/// form loads if the CurrentAutoScaleDimensions are different from the AutoScaleDimensions,
/// PerformAutoScale will be called and AutoScaleDimensions will be set to the new value to
/// match the CurrentAutoScaleDimensions by PerformAutoScale.
///
[Localizable(true)]
[Browsable(false)]
[SRCategory(SR.CatLayout)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public SizeF AutoScaleDimensions {
get {
return autoScaleDimensions;
}
[
SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters") // value is the name of the param passed in.
// So we don't have to localize it.
]
set {
if (value.Width < 0 || value.Height < 0) {
throw new ArgumentOutOfRangeException(SR.GetString(SR.ContainerControlInvalidAutoScaleDimensions), "value");
}
autoScaleDimensions = value;
if (!autoScaleDimensions.IsEmpty) {
LayoutScalingNeeded();
}
}
}
///
/// AutoScaleFactor represents the scaling factor difference between
/// CurrentAutoScaleDimensions and AutoScaleDimensions. This value is
/// calculated on the fly. Eg: If CurrentAutoScaleDimensions is 192, 192
/// and AutoScaleDimensions is 96, 96 then the AutoScaleFactor is 2.0, 2.0
///
protected SizeF AutoScaleFactor {
get {
SizeF current = CurrentAutoScaleDimensions;
SizeF saved = AutoScaleDimensions;
// If no one has configured auto scale dimensions yet, the scaling factor
// is unity.
if (saved.IsEmpty) {
return new SizeF(1.0F, 1.0F);
}
return new SizeF(current.Width / saved.Width, current.Height / saved.Height);
}
}
///
/// Determines the scaling mode of this control. The default is no scaling.
///
/// Scaling by Font is useful if you wish to have a control
/// or form stretch or shrink according to the size of the fonts in the system, and should
/// be used when the control or form's size itself does not matter.
///
/// Scaling by DPI is useful when you wish to keep a control or form a specific size
/// independent of font. for example, a control displaying a chart or other graphic
/// may want to use DPI scaling to increase in size to account for higher DPI monitors.
///
[SRCategory(SR.CatLayout)]
[SRDescription(SR.ContainerControlAutoScaleModeDescr)]
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public AutoScaleMode AutoScaleMode {
get {
return autoScaleMode;
}
set {
//valid values are 0x0 to 0x3
if (!ClientUtils.IsEnumValid(value, (int)value, (int)AutoScaleMode.None, (int)AutoScaleMode.Inherit)){
throw new InvalidEnumArgumentException("value", (int)value, typeof(AutoScaleMode));
}
bool scalingNeeded = false;
if (value != autoScaleMode) {
// Invalidate any current scaling factors. If we
// are changing AutoScaleMode to anything other than
// its default, we should clear out autoScaleDimensions as it is
// nonsensical.
if (autoScaleMode != AutoScaleMode.Inherit) {
autoScaleDimensions = SizeF.Empty;
}
currentAutoScaleDimensions = SizeF.Empty;
autoScaleMode = value;
scalingNeeded = true;
}
OnAutoScaleModeChanged();
if (scalingNeeded) {
LayoutScalingNeeded();
}
}
}
///
/// Indicates whether controls in this container will be automatically validated when the focus changes.
///
[
Browsable(false),
EditorBrowsable(EditorBrowsableState.Never),
AmbientValue(AutoValidate.Inherit),
SRCategory(SR.CatBehavior),
SRDescription(SR.ContainerControlAutoValidate),
]
public virtual AutoValidate AutoValidate {
get {
if (autoValidate == AutoValidate.Inherit) {
return GetAutoValidateForControl(this);
}
else {
return autoValidate;
}
}
set {
// PERF/FXCop: dont use Enum.IsDefined.
switch (value) {
case AutoValidate.Disable:
case AutoValidate.EnablePreventFocusChange:
case AutoValidate.EnableAllowFocusChange:
case AutoValidate.Inherit:
break;
default:
throw new InvalidEnumArgumentException("AutoValidate", (int) value, typeof(AutoValidate));
}
if (autoValidate != value) {
autoValidate = value;
OnAutoValidateChanged(EventArgs.Empty);
}
}
}
///
/// [To be supplied.]
///
[
Browsable(false),
EditorBrowsable(EditorBrowsableState.Never),
SRCategory(SR.CatPropertyChanged),
SRDescription(SR.ContainerControlOnAutoValidateChangedDescr),
]
public event EventHandler AutoValidateChanged {
add {
this.autoValidateChanged += value;
}
remove {
this.autoValidateChanged -= value;
}
}
///
///
/// The binding manager for the container control.
///
///
[
Browsable(false),
SRDescription(SR.ContainerControlBindingContextDescr)
]
public override BindingContext BindingContext {
get {
BindingContext bm = base.BindingContext;
if (bm == null) {
bm = new BindingContext();
BindingContext = bm;
}
return bm;
}
set {
base.BindingContext = value;
}
}
///
/// Container controls support ImeMode only to allow child controls to inherit it from their parents.
///
protected override bool CanEnableIme {
get {
// Note: If overriding this property make sure to copy the Debug code and call this method.
Debug.Indent();
Debug.WriteLineIf( CompModSwitches.ImeMode.Level >= TraceLevel.Info, "Inside get_CanEnableIme(), value = false" + ", this = " + this );
Debug.Unindent();
return false;
}
}
///
/// Indicates the current active control on the container control.
///
[
SRCategory(SR.CatBehavior),
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
SRDescription(SR.ContainerControlActiveControlDescr)
]
public Control ActiveControl {
get {
return activeControl;
}
set {
SetActiveControl(value);
}
}
///
/// CurrentAutoScaleDimensions represent the actual DPI or Font settings
/// of the display at runtime. If the AutoScaleMode is set to �None� then
/// the CurrentAutoScaleDimensions is equal to the ActualScaleDimensions
///
[Browsable(false)]
[SRCategory(SR.CatLayout)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
public SizeF CurrentAutoScaleDimensions {
get {
if (currentAutoScaleDimensions.IsEmpty) {
switch (AutoScaleMode) {
case AutoScaleMode.Font:
currentAutoScaleDimensions = GetFontAutoScaleDimensions();
break;
case AutoScaleMode.Dpi:
// Screen Dpi
currentAutoScaleDimensions = WindowsGraphicsCacheManager.MeasurementGraphics.DeviceContext.Dpi;
break;
default:
currentAutoScaleDimensions = AutoScaleDimensions;
break;
}
}
return currentAutoScaleDimensions;
}
}
///
/// Indicates the form that the scrollable control is assigned to. This property is read-only.
///
[
SRCategory(SR.CatAppearance),
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
SRDescription(SR.ContainerControlParentFormDescr)
]
public Form ParentForm {
get {
Debug.WriteLineIf(IntSecurity.SecurityDemand.TraceVerbose, "GetParent Demanded");
IntSecurity.GetParent.Demand();
return ParentFormInternal;
}
}
internal Form ParentFormInternal {
get {
if (ParentInternal != null) {
return ParentInternal.FindFormInternal();
}
else {
if (this is Form) {
return null;
}
return FindFormInternal();
}
}
}
// Package scope for Control
///
/// Activates the specified control.
///
bool IContainerControl.ActivateControl(Control control) {
Debug.WriteLineIf(IntSecurity.SecurityDemand.TraceVerbose, "ModifyFocus Demanded");
IntSecurity.ModifyFocus.Demand();
return ActivateControlInternal(control, true);
}
internal bool ActivateControlInternal(Control control) {
return ActivateControlInternal(control, true);
}
internal bool ActivateControlInternal(Control control, bool originator) {
Debug.WriteLineIf(Control.FocusTracing.TraceVerbose, "ContainerControl::ActivateControlInternal(" + (control == null ? "null" : control.Name) + "," + originator.ToString() + ") - " + this.Name);
// Recursive function that makes sure that the chain of active controls
// is coherent.
bool ret = true;
bool updateContainerActiveControl = false;
ContainerControl cc = null;
Control parent = this.ParentInternal;
if (parent != null)
{
cc = (parent.GetContainerControlInternal()) as ContainerControl;
if (cc != null)
{
updateContainerActiveControl = (cc.ActiveControl != this);
}
}
if (control != activeControl || updateContainerActiveControl)
{
if (updateContainerActiveControl)
{
if (!cc.ActivateControlInternal(this, false))
{
return false;
}
}
ret = AssignActiveControlInternal((control == this) ? null : control);
}
if (originator) {
ScrollActiveControlIntoView();
}
return ret;
}
///
/// Used for UserControls - checks if the control
/// has a focusable control inside or not
///
internal bool HasFocusableChild()
{
Control ctl = null;
do {
ctl = GetNextControl(ctl, true);
if (ctl != null &&
ctl.CanSelect &&
ctl.TabStop)
{
break;
}
} while (ctl != null);
return ctl != null;
}
///
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected override void AdjustFormScrollbars(bool displayScrollbars) {
base.AdjustFormScrollbars(displayScrollbars);
if (!GetScrollState(ScrollStateUserHasScrolled)) {
ScrollActiveControlIntoView();
}
}
///
/// Cleans up form state after a control has been removed.
/// Package scope for Control
///
///
/// Used to notify the AxContainer that the form
/// has been created. This should only be called if
/// there is an AX container.
///
private void AxContainerFormCreated() {
((AxHost.AxContainer)Properties.GetObject(PropAxContainer)).FormCreated();
}
///
/// Specifies whether this control can process the mnemonic or not.
///
internal override bool CanProcessMnemonic() {
#if DEBUG
TraceCanProcessMnemonic();
#endif
if( this.state[stateProcessingMnemonic]){
return true;
}
return base.CanProcessMnemonic();
}
internal AxHost.AxContainer CreateAxContainer() {
object aXContainer = Properties.GetObject(PropAxContainer);
if (aXContainer == null) {
aXContainer = new AxHost.AxContainer(this);
Properties.SetObject(PropAxContainer, aXContainer);
}
return(AxHost.AxContainer)aXContainer;
}
///
/// Disposes of the resources (other than memory) used by
/// the
///
protected override void Dispose(bool disposing) {
if (disposing) {
activeControl = null;
}
base.Dispose(disposing);
focusedControl = null;
unvalidatedControl = null;
}
///
/// Recursively enables required scaling from the given control
///
private void EnableRequiredScaling(Control start, bool enable) {
start.RequiredScalingEnabled = enable;
foreach(Control c in start.Controls) {
EnableRequiredScaling(c, enable);
}
}
///
/// Assigns focus to the activeControl. If there is no activeControl then
/// focus is given to the form.
/// package scope for Form
///
internal void FocusActiveControlInternal() {
Debug.WriteLineIf(Control.FocusTracing.TraceVerbose, "ContainerControl::FocusActiveControlInternal() - " + this.Name);
#if DEBUG
// Things really get ugly if you try to pop up an assert dialog here
if (activeControl != null && !this.Contains(activeControl))
Debug.WriteLine("ActiveControl is not a child of this ContainerControl");
#endif
if (activeControl != null && activeControl.Visible) {
// Avoid focus loops, especially with ComboBoxes, on Win98/ME.
//
IntPtr focusHandle = UnsafeNativeMethods.GetFocus();
if (focusHandle == IntPtr.Zero || Control.FromChildHandleInternal(focusHandle) != activeControl) {
UnsafeNativeMethods.SetFocus(new HandleRef(activeControl, activeControl.Handle));
}
}
else {
// Determine and focus closest visible parent
ContainerControl cc = this;
while (cc != null && !cc.Visible)
{
Control parent = cc.ParentInternal;
if (parent != null)
{
cc = parent.GetContainerControlInternal() as ContainerControl;
}
else {
break;
}
}
if (cc != null && cc.Visible)
{
UnsafeNativeMethods.SetFocus(new HandleRef(cc, cc.Handle));
}
}
}
internal override Size GetPreferredSizeCore(Size proposedSize) {
// Translating 0,0 from ClientSize to actual Size tells us how much space
// is required for the borders.
Size borderSize = SizeFromClientSize(Size.Empty);
Size totalPadding = borderSize + Padding.Size;
return LayoutEngine.GetPreferredSize(this, proposedSize - totalPadding) + totalPadding;
}
///
/// This method calcuates the auto scale dimensions based on the
/// control's current font.
///
[SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters")] // Refers to 'fontMeasureString'.
[SuppressMessage("Microsoft.Usage", "CA2204:LiteralsShouldBeSpelledCorrectly")]
private SizeF GetFontAutoScaleDimensions()
{
SizeF retval = SizeF.Empty;
// Windows uses CreateCompatibleDC(NULL) to get a
// memory DC for the monitor the application is currently
// on.
IntPtr dc = UnsafeNativeMethods.CreateCompatibleDC(NativeMethods.NullHandleRef);
if (dc == IntPtr.Zero) {
throw new Win32Exception();
}
HandleRef hdc = new HandleRef(this, dc);
try {
// We clone the Windows scaling function here as closely as
// possible. They use textmetric for height, and textmetric
// for width of fixed width fonts. For variable width fonts
// they use GetTextExtentPoint32 and pass in a long a-Z string.
// We must do the same here if our dialogs are to scale in a
// similar fashion.
HandleRef hfont = new HandleRef(this, FontHandle);
HandleRef hfontOld = new HandleRef(this, SafeNativeMethods.SelectObject(hdc, hfont));
try {
NativeMethods.TEXTMETRIC tm = new NativeMethods.TEXTMETRIC();
SafeNativeMethods.GetTextMetrics(hdc, ref tm);
retval.Height = tm.tmHeight;
if ((tm.tmPitchAndFamily & NativeMethods.TMPF_FIXED_PITCH) != 0) {
IntNativeMethods.SIZE size = new IntNativeMethods.SIZE();
IntUnsafeNativeMethods.GetTextExtentPoint32(hdc, fontMeasureString, size);
// Note: intentional integer round off here for Win32 compat
//retval.Width = (float)(((size.cx / 26) + 1) / 2);
retval.Width = (int)Math.Round(((float)size.cx) / ((float)fontMeasureString.Length));
}
else {
retval.Width = tm.tmAveCharWidth;
}
}
finally {
SafeNativeMethods.SelectObject(hdc, hfontOld);
}
}
finally {
UnsafeNativeMethods.DeleteCompatibleDC(hdc);
}
return retval;
}
///
/// This method is called when one of the auto scale properties changes, indicating
/// that we should scale controls on the next layout.
///
private void LayoutScalingNeeded() {
EnableRequiredScaling(this, true);
state[stateScalingNeededOnLayout] = true;
// If layout is not currently suspended, then perform a layout now,
// as otherwise we don't know when one will happen.
if (!IsLayoutSuspended) {
LayoutTransaction.DoLayout(this, this, PropertyNames.Bounds);
}
}
///
/// to maintain backwards compat with AutoScale on form, we need to keep the
/// two models from conflicting. This method is only here for Form to override
/// it and update its AutoScale property appropriately.
///
internal virtual void OnAutoScaleModeChanged() {
}
///
/// Raises the AutoValidateChanged event.
///
protected virtual void OnAutoValidateChanged(EventArgs e) {
if (autoValidateChanged != null) {
autoValidateChanged(this, e);
}
}
// Refer VsWhidbey : 515910 & 269769
internal override void OnFrameWindowActivate(bool fActivate) {
if (fActivate) {
IntSecurity.ModifyFocus.Assert();
try {
if (ActiveControl == null) {
SelectNextControl(null, true, true, true, false);
}
InnerMostActiveContainerControl.FocusActiveControlInternal();
}
finally {
CodeAccessPermission.RevertAssert();
}
}
}
///
/// Called when a child is about to resume its layout. The default implementation
/// calls OnChildLayoutResuming on the parent.
///
internal override void OnChildLayoutResuming(Control child, bool performLayout) {
base.OnChildLayoutResuming(child, performLayout);
// We need to scale children before their layout engines get to them.
// We don't have a lot of opportunity for that because the code
// generator always generates a PerformLayout() right after a
// ResumeLayout(false). This seems to be the most oppportune place
// for thiis, although it is unfortunate.
if (!state[stateScalingChild] && !performLayout && AutoScaleMode != AutoScaleMode.None && AutoScaleMode != AutoScaleMode.Inherit && state[stateScalingNeededOnLayout]) {
state[stateScalingChild] = true;
try {
child.Scale(AutoScaleFactor, SizeF.Empty, this);
}
finally {
state[stateScalingChild] = false;
}
}
}
///
/// Raises the CreateControl event.
///
protected override void OnCreateControl() {
base.OnCreateControl();
if (Properties.GetObject(PropAxContainer) != null) {
AxContainerFormCreated();
}
OnBindingContextChanged(EventArgs.Empty);
}
///
/// We override this to clear the current autoscale cache.
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected override void OnFontChanged(EventArgs e) {
if (AutoScaleMode == AutoScaleMode.Font) {
currentAutoScaleDimensions = SizeF.Empty;
// If the font changes and we are going to autoscale
// as a result, do it now, and wrap the entire
// transaction in a suspend layout to prevent
// the layout engines from conflicting with our
// work.
SuspendAllLayout(this);
try {
PerformAutoScale(!RequiredScalingEnabled, true);
}
finally {
ResumeAllLayout(this, false);
}
}
base.OnFontChanged(e);
}
///
/// Container controls scale during layout.
///
protected override void OnLayout(LayoutEventArgs e) {
PerformNeededAutoScaleOnLayout();
base.OnLayout(e);
}
///
/// Called when the last resume layout call is made. If performLayout is true
/// a layout will occur as soon as this call returns. Layout is
/// still suspended when this call is made. The default implementation
/// calls OnChildLayoutResuming on the parent, if it exists.
///
internal override void OnLayoutResuming(bool performLayout) {
PerformNeededAutoScaleOnLayout();
base.OnLayoutResuming(performLayout);
}
///
/// Called when the parent changes. Container controls prefer to have their parents
/// scale themselves, but when a parent is first changed, and as a result the font
/// changes as well, a container control should scale itself. We save off this state
/// so a later font change can trigger a scale of us. We only set this state if
/// required scaling is disabled: if it is enabled we are still initializing and
/// parent changes are normal.
///
protected override void OnParentChanged(EventArgs e) {
state[stateParentChanged] = !RequiredScalingEnabled;
base.OnParentChanged(e);
}
///
/// Performs scaling of this control. Scaling works by scaling all children of this control.
/// Those children that are ContainerControls will have their PerformAutoScale method called
/// so they can scale their children.
///
public void PerformAutoScale() {
PerformAutoScale(true, true);
}
///
/// Performs scaling of this control. Scaling works by scaling all children of this control.
///
/// If includedBounds is true those controls whose bounds have changed since
/// they were last scaled will be auto scaled. If excludedBounds is true those
/// controls whose bounds have not changed since they were last scaled will be
/// auto scaled.
///
/// PerformAutoScale is automatically called during OnLayout. The parameters to
/// PerformAutoScale are passed as follows:
///
/// 1. If AutoScaleDimensions are set, includedBounds is set to true.
/// 2. If a font change occurred, excludedBounds is set to true.
///
private void PerformAutoScale(bool includedBounds, bool excludedBounds) {
bool suspended = false;
try {
if (AutoScaleMode != AutoScaleMode.None && AutoScaleMode != AutoScaleMode.Inherit) {
SuspendAllLayout(this);
suspended = true;
// Walk each control recursively and scale. We search the control
// for its own set of scaling data; if we don't find it, we use the current
// container control's scaling data. Once we scale a control, we set
// its scaling factors to unity. As we walk out of a container control,
// we set its scaling factor to unity too.
SizeF included = SizeF.Empty;
SizeF excluded = SizeF.Empty;
if (includedBounds) included = AutoScaleFactor;
if (excludedBounds) excluded = AutoScaleFactor;
Scale(included, excluded, this);
autoScaleDimensions = CurrentAutoScaleDimensions;
}
}
finally {
if (includedBounds) {
state[stateScalingNeededOnLayout] = false;
EnableRequiredScaling(this, false);
}
state[stateParentChanged] = false;
if (suspended) {
ResumeAllLayout(this, false);
}
}
}
///
/// Checks to see if we need to perform an autoscale in
/// response to a layout.
///
private void PerformNeededAutoScaleOnLayout() {
if (state[stateScalingNeededOnLayout]) {
PerformAutoScale(state[stateScalingNeededOnLayout], false);
}
}
///
/// Recursively resumes all layout.
///
internal void ResumeAllLayout(Control start, bool performLayout) {
ControlCollection controlsCollection = start.Controls;
// This may have changed the sizes of our children.
// PERFNOTE: This is more efficient than using Foreach. Foreach
// forces the creation of an array subset enum each time we
// enumerate
for(int i = 0; i < controlsCollection.Count; i++) {
ResumeAllLayout(controlsCollection[i], performLayout);
}
start.ResumeLayout(performLayout);
}
///
/// Recursively suspends all layout.
///
internal void SuspendAllLayout(Control start) {
start.SuspendLayout();
CommonProperties.xClearPreferredSizeCache(start);
ControlCollection controlsCollection = start.Controls;
// This may have changed the sizes of our children.
// PERFNOTE: This is more efficient than using Foreach. Foreach
// forces the creation of an array subset enum each time we
// enumerate
for(int i = 0; i < controlsCollection.Count; i++) {
SuspendAllLayout(controlsCollection[i]);
}
}
///
/// Overrides the default scaling mechanism to account for autoscaling. This
/// override behaves as follows: any unchanged controls are always scaled
/// according to the container control's AutoScaleFactor. Any changed controls are
/// scaled according to the provided scaling factor.
///
internal override void Scale(SizeF includedFactor, SizeF excludedFactor, Control requestingControl) {
// If we're inhieriting our scaling from our parent, Scale is really easy: just do the
// base class implementation.
if (AutoScaleMode == AutoScaleMode.Inherit) {
base.Scale(includedFactor, excludedFactor, requestingControl);
}
else {
// We scale our controls based on our own auto scaling
// factor, not the one provided to us. We only do this for
// controls that are not required to be scaled (excluded controls).
SizeF ourExcludedFactor = excludedFactor;
SizeF childIncludedFactor = includedFactor;
if (!ourExcludedFactor.IsEmpty) {
ourExcludedFactor = AutoScaleFactor;
}
// If we're not supposed to be scaling, don't scale the internal
// ones either.
if (AutoScaleMode == AutoScaleMode.None) {
childIncludedFactor = AutoScaleFactor;
}
// When we scale, we are establishing new baselines for the
// positions of all controls. Therefore, we should resume(false).
using (new LayoutTransaction(this, this, PropertyNames.Bounds, false)) {
// Our own container control poses a problem. We want
// an outer control to be responsible for scaling it,
// because the outer control knows the container's dimensions.
// We detect this by checking who is requesting that the
// scaling occur.
SizeF ourExternalContainerFactor = ourExcludedFactor;
if (!excludedFactor.IsEmpty && ParentInternal != null) {
ourExternalContainerFactor = SizeF.Empty;
bool scaleUs = (requestingControl != this || state[stateParentChanged]);
// Hack for design time support: we may be parented within another form
// that is not part of the designer.
if (!scaleUs) {
bool dt = false;
bool parentDt = false;
ISite site = Site;
ISite parentSite = ParentInternal.Site;
if (site != null) dt = site.DesignMode;
if (parentSite != null) parentDt = parentSite.DesignMode;
if (dt && !parentDt) {
scaleUs = true;
}
}
if (scaleUs) {
ourExternalContainerFactor = excludedFactor;
}
}
ScaleControl(includedFactor, ourExternalContainerFactor, requestingControl);
ScaleChildControls(childIncludedFactor, ourExcludedFactor, requestingControl);
}
}
}
///
/// Process an arrowKey press by selecting the next control in the group
/// that the activeControl belongs to.
///
///
/// Processes a dialog character. Overrides Control.processDialogChar().
/// This method calls the processMnemonic() method to check if the character
/// is a mnemonic for one of the controls on the form. If processMnemonic()
/// does not consume the character, then base.processDialogChar() is
/// called.
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
[UIPermission(SecurityAction.LinkDemand, Window=UIPermissionWindow.AllWindows)]
protected override bool ProcessDialogChar(char charCode) {
#if DEBUG
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, "ContainerControl.ProcessDialogChar [" + charCode.ToString() + "]");
#endif
// If we're the top-level form or control, we need to do the mnemonic handling
//
ContainerControl parent = GetContainerControlInternal() as ContainerControl;
if (parent != null && charCode != ' ' && ProcessMnemonic(charCode)) return true;
return base.ProcessDialogChar(charCode);
}
///
/// Processes a dialog key. Overrides Control.processDialogKey(). This
/// method implements handling of the TAB, LEFT, RIGHT, UP, and DOWN
/// keys in dialogs.
/// The method performs no processing on keys that include the ALT or
/// CONTROL modifiers. For the TAB key, the method selects the next control
/// on the form. For the arrow keys,
/// !!!
///
[UIPermission(SecurityAction.LinkDemand, Window=UIPermissionWindow.AllWindows)]
protected override bool ProcessDialogKey(Keys keyData) {
#if DEBUG
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, "ContainerControl.ProcessDialogKey [" + keyData.ToString() + "]");
#endif
if ((keyData & (Keys.Alt | Keys.Control)) == Keys.None) {
Keys keyCode = (Keys)keyData & Keys.KeyCode;
switch (keyCode) {
case Keys.Tab:
if (ProcessTabKey((keyData & Keys.Shift) == Keys.None)) return true;
break;
case Keys.Left:
case Keys.Right:
case Keys.Up:
case Keys.Down:
if (ProcessArrowKey(keyCode == Keys.Right ||
keyCode == Keys.Down)) return true;
break;
}
}
return base.ProcessDialogKey(keyData);
}
/// ") + "'");
do {
// Loop through the controls starting at the control next to the current Active control in the Tab order
// till we find someone willing to process this mnemonic.
// We don't start the search on the Active control to allow controls in the same container with the same
// mnemonic (bad UI design but supported) to be processed sequentially (see VSWhidbey#428029).
#if DEBUG
count++;
if (count > 9999) {
Debug.Fail("Infinite loop trying to find controls which can ProcessMnemonic()!!!");
}
#endif //DEBUG
ctl = GetNextControl(ctl, true);
if ( ctl != null ) {
#if DEBUG
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, " ...checking for mnemonics on " + ctl.ToString());
// Control.TraceMnemonicProcessing.Enabled disables CanProcessMnemonic consistency check.
bool canProcess = Control.TraceMnemonicProcessing.Enabled ? true : ctl.CanProcessMnemonic(); // Processing the mnemonic can change the value of CanProcessMnemonic. See ASURT 39583.
#endif
// Processing the mnemonic can change the value of CanProcessMnemonic. See ASURT 39583.
if (ctl.ProcessMnemonic(charCode)) {
#if DEBUG
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, " ...mnemonics found");
Debug.Assert((Control.TraceMnemonicProcessing.Enabled || canProcess), "ProcessMnemonic returned true, even though CanProcessMnemonic() is false. Someone probably overrode ProcessMnemonic and forgot to test CanSelect or CanProcessMnemonic().");
Debug.Unindent();
#endif
processed = true;
break;
}
}
else { // ctl is null
if( wrapped ){
break; // This avoids infinite loops
}
wrapped = true;
}
} while (ctl != start);
}
finally {
this.state[stateProcessingMnemonic] = false;
}
Debug.Unindent();
return processed;
}
///
/// Selects the next available control and makes it the active control.
///
[UIPermission(SecurityAction.LinkDemand, Window=UIPermissionWindow.AllWindows)]
protected virtual bool ProcessTabKey(bool forward) {
if (SelectNextControl(activeControl, forward, true, true, false)) return true;
return false;
}
private ScrollableControl FindScrollableParent(Control ctl) {
Control current = ctl.ParentInternal;
while (current != null && !(current is ScrollableControl)) {
current = current.ParentInternal;
}
if (current != null) {
return(ScrollableControl)current;
}
return null;
}
private void ScrollActiveControlIntoView() {
Control last = activeControl;
if (last != null) {
ScrollableControl scrollParent = FindScrollableParent(last);
while (scrollParent != null) {
scrollParent.ScrollControlIntoView(activeControl);
last = scrollParent;
scrollParent = FindScrollableParent(scrollParent);
}
}
}
///
/// [To be supplied.]
///
protected override void Select(bool directed, bool forward) {
bool correctParentActiveControl = true;
if (ParentInternal != null)
{
IContainerControl c = ParentInternal.GetContainerControlInternal();
if (c != null)
{
c.ActiveControl = this;
correctParentActiveControl = (c.ActiveControl == this);
}
}
if (directed && correctParentActiveControl)
{
SelectNextControl(null, forward, true, true, false);
}
}
///
/// Implements ActiveControl property setter.
///
private void SetActiveControl(Control ctl) {
Debug.WriteLineIf(Control.FocusTracing.TraceVerbose, "ContainerControl::SetActiveControl(" + (ctl == null ? "null" : ctl.Name) + ") - " + this.Name);
Debug.WriteLineIf(IntSecurity.SecurityDemand.TraceVerbose, "ModifyFocus Demanded");
IntSecurity.ModifyFocus.Demand();
SetActiveControlInternal(ctl);
}
///
/// Unsafe version of SetActiveControl - Use with caution!
///
internal void SetActiveControlInternal(Control value) {
Debug.WriteLineIf(Control.FocusTracing.TraceVerbose, "ContainerControl::SetActiveControlInternal(" + (value == null ? "null" : value.Name) + ") - " + this.Name);
if (activeControl != value || (value != null && !value.Focused)) {
if (value != null && !Contains(value)) {
throw new ArgumentException(SR.GetString(SR.CannotActivateControl));
}
bool ret;
ContainerControl cc = this;
if (value != null && value.ParentInternal != null)
{
cc = (value.ParentInternal.GetContainerControlInternal()) as ContainerControl;
}
if (cc != null)
{
// Call to the recursive function that corrects the chain
// of active controls
ret = cc.ActivateControlInternal(value, false);
}
else
{
ret = AssignActiveControlInternal(value);
}
if (cc != null && ret)
{
ContainerControl ccAncestor = this;
while (ccAncestor.ParentInternal != null &&
ccAncestor.ParentInternal.GetContainerControlInternal() is ContainerControl)
{
ccAncestor = ccAncestor.ParentInternal.GetContainerControlInternal() as ContainerControl;
Debug.Assert(ccAncestor != null);
}
if (ccAncestor.ContainsFocus &&
(value == null ||
!(value is UserControl) ||
(value is UserControl && !((UserControl)value).HasFocusableChild())))
{
cc.FocusActiveControlInternal();
}
}
}
}
internal ContainerControl InnerMostActiveContainerControl
{
get
{
ContainerControl ret = this;
while (ret.ActiveControl is ContainerControl)
{
ret = (ContainerControl) ret.ActiveControl;
}
return ret;
}
}
internal ContainerControl InnerMostFocusedContainerControl
{
get
{
ContainerControl ret = this;
while (ret.focusedControl is ContainerControl)
{
ret = (ContainerControl) ret.focusedControl;
}
return ret;
}
}
///
/// Updates the default button based on current selection, and the
/// acceptButton property.
///
///
/// Updates the focusedControl variable by walking towards the
/// activeControl variable, firing enter and leave events and validation
/// as necessary.
///
///
/// Make sure we have a valid choice of last unvalidated control if at all possible.
///
///
/// Validates the last unvalidated control and its ancestors (up through the ancestor in common
/// with enterControl) if enterControl causes validation.
///
///
///
/// Validates the last unvalidated control and its ancestors up through, but not including the current control.
///
/// This version always performs validation, regardless of the AutoValidate setting of the control's parent.
///
///
//
// -------------------------------
// INTERNAL NOTE FOR WINFORMS DEVS: This version is intended for user code that wants to force validation, even
// while auto-validation is turned off. When adding any explicit Validate() calls to our code, consider using
// Validate(true) rather than Validate(), so that you will be sensitive to the current auto-validation setting.
// -------------------------------
//
public bool Validate() {
return Validate(false);
}
///
///
/// Validates the last unvalidated control and its ancestors up through, but not including the current control.
///
/// This version will skip validation if checkAutoValidate is true and the effective AutoValidate setting, as
/// determined by the control's parent, is AutoValidate.Disable.
///
///
public bool Validate(bool checkAutoValidate) {
bool validatedControlAllowsFocusChange;
return ValidateInternal(checkAutoValidate, out validatedControlAllowsFocusChange);
}
internal bool ValidateInternal(bool checkAutoValidate, out bool validatedControlAllowsFocusChange) {
validatedControlAllowsFocusChange = false;
if (this.AutoValidate == AutoValidate.EnablePreventFocusChange ||
(activeControl != null && activeControl.CausesValidation)) {
if (unvalidatedControl == null) {
if (focusedControl is ContainerControl && focusedControl.CausesValidation) {
ContainerControl c = (ContainerControl)focusedControl;
if( !c.ValidateInternal(checkAutoValidate, out validatedControlAllowsFocusChange) ){
return false;
}
}
else {
unvalidatedControl = focusedControl;
}
}
// Should we force focus to stay on same control if there is a validation error?
bool preventFocusChangeOnError = true;
Control controlToValidate = unvalidatedControl != null ? unvalidatedControl : focusedControl;
if (controlToValidate != null)
{
// Get the effective AutoValidate mode for unvalidated control (based on its container control)
AutoValidate autoValidateMode = Control.GetAutoValidateForControl(controlToValidate);
// Auto-validate has been turned off in container of unvalidated control - stop now
if (checkAutoValidate && autoValidateMode == AutoValidate.Disable)
{
return true;
}
preventFocusChangeOnError = (autoValidateMode == AutoValidate.EnablePreventFocusChange);
validatedControlAllowsFocusChange = (autoValidateMode == AutoValidate.EnableAllowFocusChange);
}
return ValidateThroughAncestor(null, preventFocusChangeOnError);
}
return true;
}
///
/// Validates all selectable child controls in the container, including descendants. This is
/// equivalent to calling ValidateChildren(ValidationConstraints.Selectable). See
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public virtual bool ValidateChildren() {
return ValidateChildren(ValidationConstraints.Selectable);
}
///
/// Validates all the child controls in the container. Exactly which controls are
/// validated and which controls are skipped is determined by
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public virtual bool ValidateChildren(ValidationConstraints validationConstraints) {
// validationConstraints must be a combination of
// None = 0x00, Selectable = 0x01, Enabled = 0x02, Visible = 0x04, TabStop = 0x08, ImmediateChildren = 0x10
// Not using ClientUtils.IsValidEnum here because this is a flags enum and everything is valid between 0x00 and 0x1F.
if ((int)validationConstraints < 0x00 || (int)validationConstraints > 0x1F)
{
throw new InvalidEnumArgumentException("validationConstraints", (int)validationConstraints, typeof(ValidationConstraints));
}
return !PerformContainerValidation(validationConstraints);
}
private bool ValidateThroughAncestor(Control ancestorControl, bool preventFocusChangeOnError) {
if (ancestorControl == null)
ancestorControl = this;
if (state[stateValidating])
return false;
if (unvalidatedControl == null)
unvalidatedControl = focusedControl;
//return true for a Container Control with no controls to validate....
//
if (unvalidatedControl == null)
return true;
if (!ancestorControl.IsDescendant(unvalidatedControl))
return false;
this.state[stateValidating] = true;
bool cancel = false;
Control currentActiveControl = activeControl;
Control currentValidatingControl = unvalidatedControl;
if (currentActiveControl != null) {
currentActiveControl.ValidationCancelled = false;
if (currentActiveControl is ContainerControl) {
ContainerControl currentActiveContainerControl = currentActiveControl as ContainerControl;
currentActiveContainerControl.ResetValidationFlag();
}
}
try {
while (currentValidatingControl != null && currentValidatingControl != ancestorControl) {
try {
cancel = currentValidatingControl.PerformControlValidation(false);
}
catch {
cancel = true;
throw;
}
if (cancel) {
break;
}
currentValidatingControl = currentValidatingControl.ParentInternal;
}
if (cancel && preventFocusChangeOnError) {
if (unvalidatedControl == null && currentValidatingControl != null &&
ancestorControl.IsDescendant(currentValidatingControl))
{
unvalidatedControl = currentValidatingControl;
}
// This bit 'marks' the control that was going to get the focus, so that it will ignore any pending
// mouse or key events. Otherwise it would still perform its default 'click' action or whatever.
if (currentActiveControl == activeControl) {
if (currentActiveControl != null) {
CancelEventArgs ev = new CancelEventArgs();
ev.Cancel = true;
currentActiveControl.NotifyValidationResult(currentValidatingControl, ev);
if (currentActiveControl is ContainerControl) {
ContainerControl currentActiveContainerControl = currentActiveControl as ContainerControl;
if (currentActiveContainerControl.focusedControl != null) {
currentActiveContainerControl.focusedControl.ValidationCancelled = true;
}
currentActiveContainerControl.ResetActiveAndFocusedControlsRecursive();
}
}
}
// This bit forces the focus to move back to the invalid control
SetActiveControlInternal(unvalidatedControl);
}
}
finally {
unvalidatedControl = null;
state[stateValidating] = false;
}
return !cancel;
}
private void ResetValidationFlag() {
// PERFNOTE: This is more efficient than using Foreach. Foreach
// forces the creation of an array subset enum each time we
// enumerate
Control.ControlCollection children = this.Controls;
int count = children.Count;
for(int i = 0; i < count; i++) {
children[i].ValidationCancelled = false;
}
}
internal void ResetActiveAndFocusedControlsRecursive()
{
if (activeControl is ContainerControl)
{
((ContainerControl) activeControl).ResetActiveAndFocusedControlsRecursive();
}
activeControl = null;
focusedControl = null;
}
[EditorBrowsable(EditorBrowsableState.Never)]
internal virtual bool ShouldSerializeAutoValidate() {
return autoValidate != AutoValidate.Inherit;
}
///
/// WM_SETFOCUS handler
///
///
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
protected override void WndProc(ref Message m) {
switch (m.Msg) {
case NativeMethods.WM_SETFOCUS:
WmSetFocus(ref m);
break;
default:
base.WndProc(ref m);
break;
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- KeyboardNavigation.cs
- XPathNavigator.cs
- EmissiveMaterial.cs
- HtmlShim.cs
- WsatServiceCertificate.cs
- EventRecordWrittenEventArgs.cs
- ToolBarButtonClickEvent.cs
- ContextDataSource.cs
- OdbcParameter.cs
- OpCodes.cs
- XmlValidatingReader.cs
- BreadCrumbTextConverter.cs
- cookiecollection.cs
- SelectionEditor.cs
- DrawingContext.cs
- AddressingVersion.cs
- GenericNameHandler.cs
- DataGridColumnHeaderItemAutomationPeer.cs
- WebPartTracker.cs
- TypePropertyEditor.cs
- WrappedIUnknown.cs
- TraceHandlerErrorFormatter.cs
- PkcsUtils.cs
- TimelineGroup.cs
- DataGridViewCellCancelEventArgs.cs
- ScriptingRoleServiceSection.cs
- PeerInvitationResponse.cs
- ValueTypeFixupInfo.cs
- DefaultDiscoveryServiceExtension.cs
- RoleManagerEventArgs.cs
- ElementHostAutomationPeer.cs
- XmlCharCheckingWriter.cs
- CaseStatementSlot.cs
- EditorZoneDesigner.cs
- QualificationDataAttribute.cs
- XmlSchemaIdentityConstraint.cs
- WebPartDisplayModeEventArgs.cs
- DebugView.cs
- SQLInt16.cs
- DesignerUtility.cs
- FieldCollectionEditor.cs
- DeferredReference.cs
- ThrowHelper.cs
- ArgumentException.cs
- HuffmanTree.cs
- SelectionListDesigner.cs
- TrackingDataItemValue.cs
- DbProviderFactory.cs
- BitmapImage.cs
- RawStylusInput.cs
- DataGridViewSortCompareEventArgs.cs
- RelationshipManager.cs
- WebPartUtil.cs
- SqlCacheDependency.cs
- TypeGeneratedEventArgs.cs
- Int32Rect.cs
- TypeDependencyAttribute.cs
- EdmValidator.cs
- StatusBarPanelClickEvent.cs
- GifBitmapDecoder.cs
- ScriptingRoleServiceSection.cs
- AddInServer.cs
- ConnectionPoolManager.cs
- EmptyCollection.cs
- InnerItemCollectionView.cs
- JsonGlobals.cs
- ConsoleTraceListener.cs
- FixedFlowMap.cs
- DrawingGroup.cs
- ChangeProcessor.cs
- SortAction.cs
- AudienceUriMode.cs
- StylusPointPropertyInfo.cs
- ForeignKeyConstraint.cs
- TraceProvider.cs
- EventDescriptorCollection.cs
- _Semaphore.cs
- AnonymousIdentificationModule.cs
- HttpCapabilitiesBase.cs
- XAMLParseException.cs
- SQLMembershipProvider.cs
- FontFamilyIdentifier.cs
- Renderer.cs
- ManagementDateTime.cs
- ProfilePropertyNameValidator.cs
- RawKeyboardInputReport.cs
- NavigationPropertyEmitter.cs
- BuildTopDownAttribute.cs
- CompositionTarget.cs
- DataGridViewToolTip.cs
- TextControl.cs
- RootBuilder.cs
- InputLanguage.cs
- TransactionFilter.cs
- IdleTimeoutMonitor.cs
- SamlDoNotCacheCondition.cs
- DesignerToolboxInfo.cs
- NamespaceEmitter.cs
- Permission.cs
- SettingsPropertyNotFoundException.cs