rendered paste body[DefaultProperty("Text"), ToolboxItem("System.Windows.Forms.Design.AutoSizeToolboxItem,System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"), ComVisible(true), ClassInterface(ClassInterfaceType.AutoDispatch), SRDescription("DescriptionLabel"), Designer("System.Windows.Forms.Design.LabelDesigner, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"), DefaultBindingProperty("Text")]
public class Label : Control
{
// Fields
private bool controlToolTip;
private static readonly object EVENT_TEXTALIGNCHANGED = new object();
private BitVector32 labelState = new BitVector32();
private static readonly int PropImage = PropertyStore.CreateKey();
private static readonly int PropImageAlign = PropertyStore.CreateKey();
private static readonly int PropImageIndex = PropertyStore.CreateKey();
private static readonly int PropImageList = PropertyStore.CreateKey();
private static readonly int PropTextAlign = PropertyStore.CreateKey();
private int requestedHeight;
private int requestedWidth;
internal bool showToolTip;
private static readonly BitVector32.Section StateAnimating = BitVector32.CreateSection(1, StateAutoSize);
private static readonly BitVector32.Section StateAutoEllipsis = BitVector32.CreateSection(1, StateBorderStyle);
private static readonly BitVector32.Section StateAutoSize = BitVector32.CreateSection(1, StateUseMnemonic);
private static readonly BitVector32.Section StateBorderStyle = BitVector32.CreateSection(2, StateFlatStyle);
private static readonly BitVector32.Section StateFlatStyle = BitVector32.CreateSection(3, StateAnimating);
private static readonly BitVector32.Section StateUseMnemonic = BitVector32.CreateSection(1);
private LayoutUtils.MeasureTextCache textMeasurementCache;
private ToolTip textToolTip;
// Events
[EditorBrowsable(EditorBrowsableState.Always), SRCategory("CatPropertyChanged"), SRDescription("ControlOnAutoSizeChangedDescr"), Browsable(true)]
public event EventHandler AutoSizeChanged
{
add
{
base.AutoSizeChanged += value;
}
remove
{
base.AutoSizeChanged -= value;
}
}
[EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
public event EventHandler BackgroundImageChanged
{
add
{
base.BackgroundImageChanged += value;
}
remove
{
base.BackgroundImageChanged -= value;
}
}
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler BackgroundImageLayoutChanged
{
add
{
base.BackgroundImageLayoutChanged += value;
}
remove
{
base.BackgroundImageLayoutChanged -= value;
}
}
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler ImeModeChanged
{
add
{
base.ImeModeChanged += value;
}
remove
{
base.ImeModeChanged -= value;
}
}
[EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
public event KeyEventHandler KeyDown
{
add
{
base.KeyDown += value;
}
remove
{
base.KeyDown -= value;
}
}
[EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
public event KeyPressEventHandler KeyPress
{
add
{
base.KeyPress += value;
}
remove
{
base.KeyPress -= value;
}
}
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public event KeyEventHandler KeyUp
{
add
{
base.KeyUp += value;
}
remove
{
base.KeyUp -= value;
}
}
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler TabStopChanged
{
add
{
base.TabStopChanged += value;
}
remove
{
base.TabStopChanged -= value;
}
}
[SRDescription("LabelOnTextAlignChangedDescr"), SRCategory("CatPropertyChanged")]
public event EventHandler TextAlignChanged
{
add
{
base.Events.AddHandler(EVENT_TEXTALIGNCHANGED, value);
}
remove
{
base.Events.RemoveHandler(EVENT_TEXTALIGNCHANGED, value);
}
}
// Methods
public Label()
{
base.SetState2(0x800, true);
base.SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.SupportsTransparentBackColor | ControlStyles.UserPaint, this.IsOwnerDraw());
base.SetStyle(ControlStyles.Selectable | ControlStyles.FixedHeight, false);
base.SetStyle(ControlStyles.ResizeRedraw, true);
CommonProperties.SetSelfAutoSizeInDefaultLayout(this, true);
this.labelState[StateFlatStyle] = 2;
this.labelState[StateUseMnemonic] = 1;
this.labelState[StateBorderStyle] = 0;
this.TabStop = false;
this.requestedHeight = base.Height;
this.requestedWidth = base.Width;
}
internal void AdjustSize()
{
if (this.SelfSizing && (this.AutoSize || (((this.Anchor & (AnchorStyles.Right | AnchorStyles.Left)) != (AnchorStyles.Right | AnchorStyles.Left)) && ((this.Anchor & (AnchorStyles.Bottom | AnchorStyles.Top)) != (AnchorStyles.Bottom | AnchorStyles.Top)))))
{
int requestedHeight = this.requestedHeight;
int requestedWidth = this.requestedWidth;
try
{
Size size = this.AutoSize ? base.PreferredSize : new Size(requestedWidth, requestedHeight);
base.Size = size;
}
finally
{
this.requestedHeight = requestedHeight;
this.requestedWidth = requestedWidth;
}
}
}
internal void Animate()
{
this.Animate(((!base.DesignMode && base.Visible) && base.Enabled) && (this.ParentInternal != null));
}
private void Animate(bool animate)
{
bool flag = this.labelState[StateAnimating] != 0;
if (animate != flag)
{
Image image = (Image) base.Properties.GetObject(PropImage);
if (animate)
{
if (image != null)
{
ImageAnimator.Animate(image, new EventHandler(this.OnFrameChanged));
this.labelState[StateAnimating] = animate ? 1 : 0;
}
}
else if (image != null)
{
ImageAnimator.StopAnimate(image, new EventHandler(this.OnFrameChanged));
this.labelState[StateAnimating] = animate ? 1 : 0;
}
}
}
protected Rectangle CalcImageRenderBounds(Image image, Rectangle r, ContentAlignment align)
{
Size size = image.Size;
int x = r.X + 2;
int y = r.Y + 2;
if ((align & WindowsFormsUtils.AnyRightAlign) != ((ContentAlignment) 0))
{
x = ((r.X + r.Width) - 4) - size.Width;
}
else if ((align & WindowsFormsUtils.AnyCenterAlign) != ((ContentAlignment) 0))
{
x = r.X + ((r.Width - size.Width) / 2);
}
if ((align & WindowsFormsUtils.AnyBottomAlign) != ((ContentAlignment) 0))
{
y = ((r.Y + r.Height) - 4) - size.Height;
}
else if ((align & WindowsFormsUtils.AnyTopAlign) != ((ContentAlignment) 0))
{
y = r.Y + 2;
}
else
{
y = r.Y + ((r.Height - size.Height) / 2);
}
return new Rectangle(x, y, size.Width, size.Height);
}
protected override AccessibleObject CreateAccessibilityInstance()
{
return new LabelAccessibleObject(this);
}
internal virtual StringFormat CreateStringFormat()
{
return ControlPaint.CreateStringFormat(this, this.TextAlign, this.AutoEllipsis, this.UseMnemonic);
}
private TextFormatFlags CreateTextFormatFlags()
{
return this.CreateTextFormatFlags(base.Size - this.GetBordersAndPadding());
}
internal virtual TextFormatFlags CreateTextFormatFlags(Size constrainingSize)
{
TextFormatFlags flags = ControlPaint.CreateTextFormatFlags(this, this.TextAlign, this.AutoEllipsis, this.UseMnemonic);
if (!this.MeasureTextCache.TextRequiresWordBreak(this.Text, this.Font, constrainingSize, flags))
{
flags &= ~(TextFormatFlags.TextBoxControl | TextFormatFlags.WordBreak);
}
return flags;
}
private void DetachImageList(object sender, EventArgs e)
{
this.ImageList = null;
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
this.StopAnimate();
if (this.ImageList != null)
{
this.ImageList.Disposed -= new EventHandler(this.DetachImageList);
this.ImageList.RecreateHandle -= new EventHandler(this.ImageListRecreateHandle);
base.Properties.SetObject(PropImageList, null);
}
if (this.Image != null)
{
base.Properties.SetObject(PropImage, null);
}
if (this.textToolTip != null)
{
this.textToolTip.Dispose();
this.textToolTip = null;
}
this.controlToolTip = false;
}
base.Dispose(disposing);
}
protected void DrawImage(Graphics g, Image image, Rectangle r, ContentAlignment align)
{
Rectangle rectangle = this.CalcImageRenderBounds(image, r, align);
if (!base.Enabled)
{
ControlPaint.DrawImageDisabled(g, image, rectangle.X, rectangle.Y, this.BackColor);
}
else
{
g.DrawImage(image, rectangle.X, rectangle.Y, image.Width, image.Height);
}
}
private Size GetBordersAndPadding()
{
Size size = base.Padding.Size;
if (this.UseCompatibleTextRendering)
{
if (this.BorderStyle != BorderStyle.None)
{
size.Height += 6;
size.Width += 2;
return size;
}
size.Height += 3;
return size;
}
size += this.SizeFromClientSize(Size.Empty);
if (this.BorderStyle == BorderStyle.Fixed3D)
{
size += new Size(2, 2);
}
return size;
}
private int GetLeadingTextPaddingFromTextFormatFlags()
{
int iLeftMargin;
if (!base.IsHandleCreated)
{
return 0;
}
if (this.UseCompatibleTextRendering && (this.FlatStyle != FlatStyle.System))
{
return 0;
}
using (WindowsGraphics graphics = WindowsGraphics.FromHwnd(base.Handle))
{
TextFormatFlags flags = this.CreateTextFormatFlags();
if ((flags & TextFormatFlags.NoPadding) == TextFormatFlags.NoPadding)
{
graphics.TextPadding = TextPaddingOptions.NoPadding;
}
else if ((flags & TextFormatFlags.LeftAndRightPadding) == TextFormatFlags.LeftAndRightPadding)
{
graphics.TextPadding = TextPaddingOptions.LeftAndRightPadding;
}
using (WindowsFont font = WindowsGraphicsCacheManager.GetWindowsFont(this.Font))
{
iLeftMargin = graphics.GetTextMargins(font).iLeftMargin;
}
}
return iLeftMargin;
}
public override Size GetPreferredSize(Size proposedSize)
{
if (proposedSize.Width == 1)
{
proposedSize.Width = 0;
}
if (proposedSize.Height == 1)
{
proposedSize.Height = 0;
}
return base.GetPreferredSize(proposedSize);
}
internal override Size GetPreferredSizeCore(Size proposedConstraints)
{
Size textExtent;
Size bordersAndPadding = this.GetBordersAndPadding();
proposedConstraints -= bordersAndPadding;
proposedConstraints = LayoutUtils.UnionSizes(proposedConstraints, Size.Empty);
if (string.IsNullOrEmpty(this.Text))
{
using (WindowsFont font = WindowsFont.FromFont(this.Font))
{
textExtent = WindowsGraphicsCacheManager.MeasurementGraphics.GetTextExtent("0", font);
textExtent.Width = 0;
goto Label_0113;
}
}
if (this.UseGDIMeasuring())
{
TextFormatFlags flags = (this.FlatStyle == FlatStyle.System) ? TextFormatFlags.GlyphOverhangPadding : this.CreateTextFormatFlags(proposedConstraints);
textExtent = this.MeasureTextCache.GetTextSize(this.Text, this.Font, proposedConstraints, flags);
}
else
{
using (Graphics graphics = WindowsFormsUtils.CreateMeasurementGraphics())
{
using (StringFormat format = this.CreateStringFormat())
{
SizeF layoutArea = (proposedConstraints.Width == 1) ? new SizeF(0f, (float) proposedConstraints.Height) : new SizeF((float) proposedConstraints.Width, (float) proposedConstraints.Height);
textExtent = Size.Ceiling(graphics.MeasureString(this.Text, this.Font, layoutArea, format));
}
}
}
Label_0113:
return (textExtent + bordersAndPadding);
}
private void ImageListRecreateHandle(object sender, EventArgs e)
{
if (base.IsHandleCreated)
{
base.Invalidate();
}
}
internal bool IsOwnerDraw()
{
return (this.FlatStyle != FlatStyle.System);
}
internal virtual void OnAutoEllipsisChanged()
{
}
protected override void OnEnabledChanged(EventArgs e)
{
base.OnEnabledChanged(e);
this.Animate();
}
protected override void OnFontChanged(EventArgs e)
{
this.MeasureTextCache.InvalidateCache();
base.OnFontChanged(e);
this.AdjustSize();
base.Invalidate();
}
private void OnFrameChanged(object o, EventArgs e)
{
if (!base.Disposing && !base.IsDisposed)
{
if (base.IsHandleCreated && base.InvokeRequired)
{
base.BeginInvoke(new EventHandler(this.OnFrameChanged), new object[] { o, e });
}
else if (base.IsWindowObscured)
{
this.StopAnimate();
}
else
{
base.Invalidate();
}
}
}
protected override void OnHandleDestroyed(EventArgs e)
{
base.OnHandleDestroyed(e);
if ((this.textToolTip != null) && this.textToolTip.GetHandleCreated())
{
this.textToolTip.DestroyHandle();
}
}
protected override void OnMouseEnter(EventArgs e)
{
if (((!this.controlToolTip && !base.DesignMode) && (this.AutoEllipsis && this.showToolTip)) && (this.textToolTip != null))
{
IntSecurity.AllWindows.Assert();
try
{
this.controlToolTip = true;
this.textToolTip.Show(WindowsFormsUtils.TextWithoutMnemonics(this.Text), this);
}
finally
{
CodeAccessPermission.RevertAssert();
this.controlToolTip = false;
}
}
base.OnMouseEnter(e);
}
protected override void OnMouseLeave(EventArgs e)
{
if ((!this.controlToolTip && (this.textToolTip != null)) && this.textToolTip.GetHandleCreated())
{
this.textToolTip.RemoveAll();
IntSecurity.AllWindows.Assert();
try
{
this.textToolTip.Hide(this);
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
base.OnMouseLeave(e);
}
protected override void OnPaddingChanged(EventArgs e)
{
base.OnPaddingChanged(e);
this.AdjustSize();
}
protected override void OnPaint(PaintEventArgs e)
{
Color nearestColor;
this.Animate();
Rectangle r = LayoutUtils.DeflateRect(base.ClientRectangle, base.Padding);
ImageAnimator.UpdateFrames();
Image image = this.Image;
if (image != null)
{
this.DrawImage(e.Graphics, image, r, base.RtlTranslateAlignment(this.ImageAlign));
}
IntPtr hdc = e.Graphics.GetHdc();
try
{
using (WindowsGraphics graphics = WindowsGraphics.FromHdc(hdc))
{
nearestColor = graphics.GetNearestColor(base.Enabled ? this.ForeColor : base.DisabledColor);
}
}
finally
{
e.Graphics.ReleaseHdc();
}
if (this.AutoEllipsis)
{
Rectangle clientRectangle = base.ClientRectangle;
Size preferredSize = this.GetPreferredSize(new Size(clientRectangle.Width, clientRectangle.Height));
this.showToolTip = (clientRectangle.Width < preferredSize.Width) || (clientRectangle.Height < preferredSize.Height);
}
else
{
this.showToolTip = false;
}
if (this.UseCompatibleTextRendering)
{
using (StringFormat format = this.CreateStringFormat())
{
if (base.Enabled)
{
using (Brush brush = new SolidBrush(nearestColor))
{
e.Graphics.DrawString(this.Text, this.Font, brush, r, format);
goto Label_01BF;
}
}
ControlPaint.DrawStringDisabled(e.Graphics, this.Text, this.Font, nearestColor, r, format);
goto Label_01BF;
}
}
TextFormatFlags flags = this.CreateTextFormatFlags();
if (base.Enabled)
{
TextRenderer.DrawText(e.Graphics, this.Text, this.Font, r, nearestColor, flags);
}
else
{
Color foreColor = TextRenderer.DisabledTextColor(this.BackColor);
TextRenderer.DrawText(e.Graphics, this.Text, this.Font, r, foreColor, flags);
}
Label_01BF:
base.OnPaint(e);
}
protected override void OnParentChanged(EventArgs e)
{
base.OnParentChanged(e);
if (this.SelfSizing)
{
this.AdjustSize();
}
this.Animate();
}
protected override void OnRightToLeftChanged(EventArgs e)
{
this.MeasureTextCache.InvalidateCache();
base.OnRightToLeftChanged(e);
}
protected virtual void OnTextAlignChanged(EventArgs e)
{
EventHandler handler = base.Events[EVENT_TEXTALIGNCHANGED] as EventHandler;
if (handler != null)
{
handler(this, e);
}
}
protected override void OnTextChanged(EventArgs e)
{
using (LayoutTransaction.CreateTransactionIf(this.AutoSize, this.ParentInternal, this, PropertyNames.Text))
{
this.MeasureTextCache.InvalidateCache();
base.OnTextChanged(e);
this.AdjustSize();
base.Invalidate();
}
}
protected override void OnVisibleChanged(EventArgs e)
{
base.OnVisibleChanged(e);
this.Animate();
}
internal override void PrintToMetaFileRecursive(HandleRef hDC, IntPtr lParam, Rectangle bounds)
{
base.PrintToMetaFileRecursive(hDC, lParam, bounds);
using (new WindowsFormsUtils.DCMapping(hDC, bounds))
{
using (Graphics graphics = Graphics.FromHdcInternal(hDC.Handle))
{
ControlPaint.PrintBorder(graphics, new Rectangle(Point.Empty, base.Size), this.BorderStyle, Border3DStyle.SunkenOuter);
}
}
}
[UIPermission(SecurityAction.LinkDemand, Window=UIPermissionWindow.AllWindows)]
protected internal override bool ProcessMnemonic(char charCode)
{
if ((!this.UseMnemonic || !Control.IsMnemonic(charCode, this.Text)) || !this.CanProcessMnemonic())
{
return false;
}
Control parentInternal = this.ParentInternal;
if (parentInternal != null)
{
IntSecurity.ModifyFocus.Assert();
try
{
if (parentInternal.SelectNextControl(this, true, false, true, false) && !parentInternal.ContainsFocus)
{
parentInternal.Focus();
}
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
return true;
}
private void ResetImage()
{
this.Image = null;
}
protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified)
{
if ((specified & BoundsSpecified.Height) != BoundsSpecified.None)
{
this.requestedHeight = height;
}
if ((specified & BoundsSpecified.Width) != BoundsSpecified.None)
{
this.requestedWidth = width;
}
if (this.AutoSize && this.SelfSizing)
{
Size preferredSize = base.PreferredSize;
width = preferredSize.Width;
height = preferredSize.Height;
}
base.SetBoundsCore(x, y, width, height, specified);
}
internal void SetToolTip(ToolTip toolTip)
{
if ((toolTip != null) && !this.controlToolTip)
{
this.controlToolTip = true;
}
}
private bool ShouldSerializeImage()
{
return (base.Properties.GetObject(PropImage) != null);
}
internal void StopAnimate()
{
this.Animate(false);
}
public override string ToString()
{
return (base.ToString() + ", Text: " + this.Text);
}
internal virtual bool UseGDIMeasuring()
{
if (this.FlatStyle != FlatStyle.System)
{
return !this.UseCompatibleTextRendering;
}
return true;
}
[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
protected override void WndProc(ref Message m)
{
if (m.Msg == 0x84)
{
Rectangle rectangle = base.RectangleToScreen(new Rectangle(0, 0, base.Width, base.Height));
Point pt = new Point((int) ((long) m.LParam));
m.Result = rectangle.Contains(pt) ? ((IntPtr) 1) : IntPtr.Zero;
}
else
{
base.WndProc(ref m);
}
}
// Properties
[SRCategory("CatBehavior"), DefaultValue(false), Browsable(true), EditorBrowsable(EditorBrowsableState.Always), SRDescription("LabelAutoEllipsisDescr")]
public bool AutoEllipsis
{
get
{
return (this.labelState[StateAutoEllipsis] != 0);
}
set
{
if (this.AutoEllipsis != value)
{
this.labelState[StateAutoEllipsis] = value ? 1 : 0;
this.MeasureTextCache.InvalidateCache();
this.OnAutoEllipsisChanged();
if (value && (this.textToolTip == null))
{
this.textToolTip = new ToolTip();
}
if (this.ParentInternal != null)
{
LayoutTransaction.DoLayoutIf(this.AutoSize, this.ParentInternal, this, PropertyNames.AutoEllipsis);
}
base.Invalidate();
}
}
}
[Localizable(true), EditorBrowsable(EditorBrowsableState.Always), SRCategory("CatLayout"), DefaultValue(false), Browsable(true), RefreshProperties(RefreshProperties.All), SRDescription("LabelAutoSizeDescr"), DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
public override bool AutoSize
{
get
{
return base.AutoSize;
}
set
{
if (this.AutoSize != value)
{
base.AutoSize = value;
this.AdjustSize();
}
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), EditorBrowsable(EditorBrowsableState.Never), Browsable(false), SRDescription("LabelBackgroundImageDescr"), SRCategory("CatAppearance")]
public override Image BackgroundImage
{
get
{
return base.BackgroundImage;
}
set
{
base.BackgroundImage = value;
}
}
[EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
public override ImageLayout BackgroundImageLayout
{
get
{
return base.BackgroundImageLayout;
}
set
{
base.BackgroundImageLayout = value;
}
}
[SRDescription("LabelBorderDescr"), SRCategory("CatAppearance"), DefaultValue(0), DispId(-504)]
public virtual BorderStyle BorderStyle
{
get
{
return (BorderStyle) this.labelState[StateBorderStyle];
}
set
{
if (!ClientUtils.IsEnumValid(value, (int) value, 0, 2))
{
throw new InvalidEnumArgumentException("value", (int) value, typeof(BorderStyle));
}
if (this.BorderStyle != value)
{
this.labelState[StateBorderStyle] = (int) value;
if (this.ParentInternal != null)
{
LayoutTransaction.DoLayoutIf(this.AutoSize, this.ParentInternal, this, PropertyNames.BorderStyle);
}
if (this.AutoSize)
{
this.AdjustSize();
}
base.RecreateHandle();
}
}
}
internal virtual bool CanUseTextRenderer
{
get
{
return true;
}
}
protected override CreateParams CreateParams
{
[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
get
{
CreateParams createParams = base.CreateParams;
createParams.ClassName = "STATIC";
if (this.OwnerDraw)
{
createParams.Style |= 13;
createParams.ExStyle &= -4097;
}
if (!this.OwnerDraw)
{
switch (this.TextAlign)
{
case ContentAlignment.TopLeft:
case ContentAlignment.MiddleLeft:
case ContentAlignment.BottomLeft:
createParams.Style = createParams.Style;
goto Label_00D9;
case ContentAlignment.TopCenter:
case ContentAlignment.MiddleCenter:
case ContentAlignment.BottomCenter:
createParams.Style |= 1;
goto Label_00D9;
case (ContentAlignment.TopCenter | ContentAlignment.TopLeft):
goto Label_00D9;
case ContentAlignment.TopRight:
case ContentAlignment.BottomRight:
case ContentAlignment.MiddleRight:
createParams.Style |= 2;
goto Label_00D9;
}
}
else
{
createParams.Style = createParams.Style;
}
Label_00D9:
switch (this.BorderStyle)
{
case BorderStyle.FixedSingle:
createParams.Style |= 0x800000;
break;
case BorderStyle.Fixed3D:
createParams.Style |= 0x1000;
break;
}
if (!this.UseMnemonic)
{
createParams.Style |= 0x80;
}
return createParams;
}
}
protected override ImeMode DefaultImeMode
{
get
{
return ImeMode.Disable;
}
}
protected override Padding DefaultMargin
{
get
{
return new Padding(3, 0, 3, 0);
}
}
protected override Size DefaultSize
{
get
{
return new Size(100, this.AutoSize ? this.PreferredHeight : 0x17);
}
}
[SRCategory("CatAppearance"), DefaultValue(2), SRDescription("ButtonFlatStyleDescr")]
public FlatStyle FlatStyle
{
get
{
return (FlatStyle) this.labelState[StateFlatStyle];
}
set
{
if (!ClientUtils.IsEnumValid(value, (int) value, 0, 3))
{
throw new InvalidEnumArgumentException("value", (int) value, typeof(FlatStyle));
}
if (this.labelState[StateFlatStyle] != value)
{
bool flag = (this.labelState[StateFlatStyle] == 3) || (value == FlatStyle.System);
this.labelState[StateFlatStyle] = (int) value;
base.SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.SupportsTransparentBackColor | ControlStyles.UserPaint, this.OwnerDraw);
if (flag)
{
LayoutTransaction.DoLayoutIf(this.AutoSize, this.ParentInternal, this, PropertyNames.BorderStyle);
if (this.AutoSize)
{
this.AdjustSize();
}
base.RecreateHandle();
}
else
{
this.Refresh();
}
}
}
}
[SRDescription("ButtonImageDescr"), Localizable(true), SRCategory("CatAppearance")]
public Image Image
{
get
{
Image image = (Image) base.Properties.GetObject(PropImage);
if (((image == null) && (this.ImageList != null)) && (this.ImageIndexer.ActualIndex >= 0))
{
return this.ImageList.Images[this.ImageIndexer.ActualIndex];
}
return image;
}
set
{
if (this.Image != value)
{
this.StopAnimate();
base.Properties.SetObject(PropImage, value);
if (value != null)
{
this.ImageIndex = -1;
this.ImageList = null;
}
this.Animate();
base.Invalidate();
}
}
}
[SRDescription("ButtonImageAlignDescr"), SRCategory("CatAppearance"), DefaultValue(0x20), Localizable(true)]
public ContentAlignment ImageAlign
{
get
{
bool flag;
int integer = base.Properties.GetInteger(PropImageAlign, out flag);
if (flag)
{
return (ContentAlignment) integer;
}
return ContentAlignment.MiddleCenter;
}
set
{
if (!WindowsFormsUtils.EnumValidator.IsValidContentAlignment(value))
{
throw new InvalidEnumArgumentException("value", (int) value, typeof(ContentAlignment));
}
if (value != this.ImageAlign)
{
base.Properties.SetInteger(PropImageAlign, (int) value);
LayoutTransaction.DoLayoutIf(this.AutoSize, this.ParentInternal, this, PropertyNames.ImageAlign);
base.Invalidate();
}
}
}
[SRDescription("ButtonImageIndexDescr"), SRCategory("CatAppearance"), TypeConverter(typeof(ImageIndexConverter)), Editor("System.Windows.Forms.Design.ImageIndexEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor)), DefaultValue(-1), RefreshProperties(RefreshProperties.Repaint), Localizable(true)]
public int ImageIndex
{
get
{
if (this.ImageIndexer == null)
{
return -1;
}
int index = this.ImageIndexer.Index;
if ((this.ImageList != null) && (index >= this.ImageList.Images.Count))
{
return (this.ImageList.Images.Count - 1);
}
return index;
}
set
{
if (value < -1)
{
object[] args = new object[] { "ImageIndex", value.ToString(CultureInfo.CurrentCulture), -1.ToString(CultureInfo.CurrentCulture) };
throw new ArgumentOutOfRangeException("ImageIndex", SR.GetString("InvalidLowBoundArgumentEx", args));
}
if (this.ImageIndex != value)
{
if (value != -1)
{
base.Properties.SetObject(PropImage, null);
}
this.ImageIndexer.Index = value;
base.Invalidate();
}
}
}
internal LabelImageIndexer ImageIndexer
{
get
{
bool flag;
LabelImageIndexer indexer = base.Properties.GetObject(PropImageIndex, out flag) as LabelImageIndexer;
if ((indexer == null) || !flag)
{
indexer = new LabelImageIndexer(this);
this.ImageIndexer = indexer;
}
return indexer;
}
set
{
base.Properties.SetObject(PropImageIndex, value);
}
}
[SRDescription("ButtonImageIndexDescr"), SRCategory("CatAppearance"), TypeConverter(typeof(ImageKeyConverter)), Localizable(true), Editor("System.Windows.Forms.Design.ImageIndexEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor)), DefaultValue(""), RefreshProperties(RefreshProperties.Repaint)]
public string ImageKey
{
get
{
if (this.ImageIndexer != null)
{
return this.ImageIndexer.Key;
}
return null;
}
set
{
if (this.ImageKey != value)
{
base.Properties.SetObject(PropImage, null);
this.ImageIndexer.Key = value;
base.Invalidate();
}
}
}
[SRDescription("ButtonImageListDescr"), RefreshProperties(RefreshProperties.Repaint), SRCategory("CatAppearance"), DefaultValue((string) null)]
public ImageList ImageList
{
get
{
return (ImageList) base.Properties.GetObject(PropImageList);
}
set
{
if (this.ImageList != value)
{
EventHandler handler = new EventHandler(this.ImageListRecreateHandle);
EventHandler handler2 = new EventHandler(this.DetachImageList);
ImageList imageList = this.ImageList;
if (imageList != null)
{
imageList.RecreateHandle -= handler;
imageList.Disposed -= handler2;
}
if (value != null)
{
base.Properties.SetObject(PropImage, null);
}
base.Properties.SetObject(PropImageList, value);
if (value != null)
{
value.RecreateHandle += handler;
value.Disposed += handler2;
}
base.Invalidate();
}
}
}
[EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
public ImeMode ImeMode
{
get
{
return base.ImeMode;
}
set
{
base.ImeMode = value;
}
}
internal override bool IsMnemonicsListenerAxSourced
{
get
{
return true;
}
}
internal LayoutUtils.MeasureTextCache MeasureTextCache
{
get
{
if (this.textMeasurementCache == null)
{
this.textMeasurementCache = new LayoutUtils.MeasureTextCache();
}
return this.textMeasurementCache;
}
}
internal virtual bool OwnerDraw
{
get
{
return this.IsOwnerDraw();
}
}
[EditorBrowsable(EditorBrowsableState.Advanced), Browsable(false), SRCategory("CatLayout"), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), SRDescription("LabelPreferredHeightDescr")]
public virtual int PreferredHeight
{
get
{
return base.PreferredSize.Height;
}
}
[SRCategory("CatLayout"), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced), SRDescription("LabelPreferredWidthDescr")]
public virtual int PreferredWidth
{
get
{
return base.PreferredSize.Width;
}
}
[Obsolete("This property has been deprecated. Use BackColor instead. http://go.microsoft.com/fwlink/?linkid=14202")]
protected virtual bool RenderTransparent
{
get
{
return base.RenderTransparent;
}
set
{
}
}
private bool SelfSizing
{
get
{
return CommonProperties.ShouldSelfSize(this);
}
}
internal override bool SupportsUseCompatibleTextRendering
{
get
{
return true;
}
}
[EditorBrowsable(EditorBrowsableState.Never), DefaultValue(false), Browsable(false)]
public bool TabStop
{
get
{
return base.TabStop;
}
set
{
base.TabStop = value;
}
}
[Editor("System.ComponentModel.Design.MultilineStringEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor)), SettingsBindable(true)]
public override string Text
{
get
{
return base.Text;
}
set
{
base.Text = value;
}
}
[SRDescription("LabelTextAlignDescr"), Localizable(true), DefaultValue(1), SRCategory("CatAppearance")]
public virtual ContentAlignment TextAlign
{
get
{
bool flag;
int integer = base.Properties.GetInteger(PropTextAlign, out flag);
if (flag)
{
return (ContentAlignment) integer;
}
return ContentAlignment.TopLeft;
}
set
{
if (!WindowsFormsUtils.EnumValidator.IsValidContentAlignment(value))
{
throw new InvalidEnumArgumentException("value", (int) value, typeof(ContentAlignment));
}
if (this.TextAlign != value)
{
base.Properties.SetInteger(PropTextAlign, (int) value);
base.Invalidate();
if (!this.OwnerDraw)
{
base.RecreateHandle();
}
this.OnTextAlignChanged(EventArgs.Empty);
}
}
}
[SRDescription("UseCompatibleTextRenderingDescr"), SRCategory("CatBehavior"), DefaultValue(false)]
public bool UseCompatibleTextRendering
{
get
{
if (this.CanUseTextRenderer)
{
return base.UseCompatibleTextRenderingInt;
}
return true;
}
set
{
if (base.UseCompatibleTextRenderingInt != value)
{
base.UseCompatibleTextRenderingInt = value;
this.AdjustSize();
}
}
}
[SRCategory("CatAppearance"), DefaultValue(true), SRDescription("LabelUseMnemonicDescr")]
public bool UseMnemonic
{
get
{
return (this.labelState[StateUseMnemonic] != 0);
}
set
{
if (this.UseMnemonic != value)
{
this.labelState[StateUseMnemonic] = value ? 1 : 0;
this.MeasureTextCache.InvalidateCache();
using (LayoutTransaction.CreateTransactionIf(this.AutoSize, this.ParentInternal, this, PropertyNames.Text))
{
this.AdjustSize();
base.Invalidate();
}
if (base.IsHandleCreated)
{
int windowStyle = base.WindowStyle;
if (!this.UseMnemonic)
{
windowStyle |= 0x80;
}
else
{
windowStyle &= -129;
}
base.WindowStyle = windowStyle;
}
}
}
}
// Nested Types
[ComVisible(true)]
internal class LabelAccessibleObject : Control.ControlAccessibleObject
{
// Methods
public LabelAccessibleObject(Label owner) : base(owner)
{
}
// Properties
public override AccessibleRole Role
{
get
{
AccessibleRole accessibleRole = base.Owner.AccessibleRole;
if (accessibleRole != AccessibleRole.Default)
{
return accessibleRole;
}
return AccessibleRole.StaticText;
}
}
}
}