Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / WinForms / Managed / System / WinForms / ToolBar.cs / 1 / ToolBar.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
namespace System.Windows.Forms {
using System.Runtime.Serialization.Formatters;
using System.Runtime.Remoting;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Diagnostics;
using System;
using System.Security.Permissions;
using System.Drawing;
using System.Collections;
using System.ComponentModel.Design;
using Microsoft.Win32;
using System.Globalization;
///
/// Represents a Windows toolbar.
///
[
ComVisible(true),
ClassInterface(ClassInterfaceType.AutoDispatch),
DefaultEvent("ButtonClick"),
Designer("System.Windows.Forms.Design.ToolBarDesigner, " + AssemblyRef.SystemDesign),
DefaultProperty("Buttons")
]
public class ToolBar : Control {
private ToolBarButtonCollection buttonsCollection;
///
/// The size of a button in the ToolBar
///
internal Size buttonSize = System.Drawing.Size.Empty;
///
/// This is used by our autoSizing support.
///
private int requestedSize;
///
/// This represents the width of the drop down arrow we have if the
/// DropDownArrows property is true. this value is used by the ToolBarButton
/// objects to compute their size
///
internal const int DDARROW_WIDTH = 15;
///
/// Indicates what our appearance will be. This will either be normal
/// or flat.
///
private ToolBarAppearance appearance = ToolBarAppearance.Normal;
///
/// Indicates whether or not we have a border
///
private BorderStyle borderStyle = System.Windows.Forms.BorderStyle.None;
///
/// The array of buttons we're working with.
///
private ToolBarButton [] buttons;
///
/// The number of buttons we're working with
///
private int buttonCount = 0;
///
/// Indicates if text captions should go underneath images in buttons or
/// to the right of them
///
private ToolBarTextAlign textAlign = ToolBarTextAlign.Underneath;
///
/// The ImageList object that contains the main images for our control.
///
private ImageList imageList = null;
///
/// The maximum width of buttons currently being displayed. This is needed
/// by our autoSizing code. If this value is -1, it needs to be recomputed.
///
private int maxWidth = -1;
///
/// To be supplied.
///
private int hotItem = -1;
// VSWhidbey 219660: Track the current scale factor so we can scale our buttons
private float currentScaleDX = 1.0F;
private float currentScaleDY = 1.0F;
private const int TOOLBARSTATE_wrappable = 0x00000001;
private const int TOOLBARSTATE_dropDownArrows = 0x00000002;
private const int TOOLBARSTATE_divider = 0x00000004;
private const int TOOLBARSTATE_showToolTips = 0x00000008;
private const int TOOLBARSTATE_autoSize = 0x00000010;
// PERF: take all the bools and put them into a state variable
private System.Collections.Specialized.BitVector32 toolBarState; // see TOOLBARSTATE_ consts above
// event handlers
//
private ToolBarButtonClickEventHandler onButtonClick = null;
private ToolBarButtonClickEventHandler onButtonDropDown = null;
///
/// Initializes a new instance of the
///
public ToolBar()
: base() {
// Set this BEFORE calling any other methods so that these defaults will be propagated
toolBarState = new System.Collections.Specialized.BitVector32(TOOLBARSTATE_autoSize |
TOOLBARSTATE_showToolTips |
TOOLBARSTATE_divider |
TOOLBARSTATE_dropDownArrows |
TOOLBARSTATE_wrappable);
SetStyle(ControlStyles.UserPaint, false);
SetStyle(ControlStyles.FixedHeight, AutoSize);
SetStyle(ControlStyles.FixedWidth, false);
TabStop = false;
Dock = DockStyle.Top;
buttonsCollection = new ToolBarButtonCollection(this);
}
///
/// Gets or sets the appearance of the toolbar
/// control and its buttons.
///
[
SRCategory(SR.CatBehavior),
DefaultValue(ToolBarAppearance.Normal),
Localizable(true),
SRDescription(SR.ToolBarAppearanceDescr)
]
public ToolBarAppearance Appearance {
get {
return appearance;
}
set {
//valid values are 0x0 to 0x1
if (!ClientUtils.IsEnumValid(value, (int)value, (int)ToolBarAppearance.Normal, (int)ToolBarAppearance.Flat)){
throw new InvalidEnumArgumentException("value", (int)value, typeof(ToolBarAppearance));
}
if (value != appearance) {
appearance = value;
RecreateHandle();
}
}
}
///
/// Indicates whether the toolbar
/// adjusts its size automatically based on the size of the buttons and the
/// dock style.
///
[
SRCategory(SR.CatBehavior),
DefaultValue(true),
Localizable(true),
SRDescription(SR.ToolBarAutoSizeDescr),
Browsable(true),
EditorBrowsable(EditorBrowsableState.Always),
DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)
]
public override bool AutoSize {
get {
return toolBarState[TOOLBARSTATE_autoSize];
}
set {
// Note that we intentionally do not call base. Toolbars size themselves by
// overriding SetBoundsCore (old RTM code). We let CommonProperties.GetAutoSize
// continue to return false to keep our LayoutEngines from messing with TextBoxes.
// This is done for backwards compatibility since the new AutoSize behavior differs.
if (AutoSize != value) {
toolBarState[TOOLBARSTATE_autoSize] = value;
if (Dock == DockStyle.Left || Dock == DockStyle.Right) {
SetStyle(ControlStyles.FixedWidth, AutoSize);
SetStyle(ControlStyles.FixedHeight, false);
}
else {
SetStyle(ControlStyles.FixedHeight, AutoSize);
SetStyle(ControlStyles.FixedWidth, false);
}
AdjustSize(Dock);
OnAutoSizeChanged(EventArgs.Empty);
}
}
}
///
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override Color BackColor {
get {
return base.BackColor;
}
set {
base.BackColor = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override Image BackgroundImage {
get {
return base.BackgroundImage;
}
set {
base.BackgroundImage = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override ImageLayout BackgroundImageLayout {
get {
return base.BackgroundImageLayout;
}
set {
base.BackgroundImageLayout = value;
}
}
///
/// Gets or sets
/// the border style of the toolbar control.
///
[
SRCategory(SR.CatAppearance),
DefaultValue(BorderStyle.None),
DispId(NativeMethods.ActiveX.DISPID_BORDERSTYLE),
SRDescription(SR.ToolBarBorderStyleDescr)
]
public BorderStyle BorderStyle {
get {
return borderStyle;
}
set {
//valid values are 0x0 to 0x2
if (!ClientUtils.IsEnumValid(value, (int)value, (int)BorderStyle.None, (int)BorderStyle.Fixed3D)){
throw new InvalidEnumArgumentException("value", (int)value, typeof(BorderStyle));
}
if (borderStyle != value) {
borderStyle = value;
//UpdateStyles();
RecreateHandle(); // Looks like we need to recreate the handle to avoid painting glitches
}
}
}
///
/// A collection of
///
[
SRCategory(SR.CatBehavior),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
Localizable(true),
SRDescription(SR.ToolBarButtonsDescr),
MergableProperty(false)
]
public ToolBarButtonCollection Buttons {
get {
return buttonsCollection;
}
}
///
/// Gets or sets
/// the size of the buttons on the toolbar control.
///
[
SRCategory(SR.CatAppearance),
RefreshProperties(RefreshProperties.All),
Localizable(true),
SRDescription(SR.ToolBarButtonSizeDescr)
]
public Size ButtonSize {
get {
if (buttonSize.IsEmpty) {
// Obtain the current buttonsize of the first button from the winctl control
//
if (IsHandleCreated && buttons != null && buttonCount > 0) {
int result = (int)SendMessage(NativeMethods.TB_GETBUTTONSIZE, 0, 0);
if (result > 0) {
return new Size(NativeMethods.Util.LOWORD(result), NativeMethods.Util.HIWORD(result));
}
}
if (TextAlign == ToolBarTextAlign.Underneath) {
return new Size(39, 36); // Default button size
}
else {
return new Size(23, 22); // Default button size
}
}
else {
return buttonSize;
}
}
set {
if (value.Width < 0 || value.Height < 0)
throw new ArgumentOutOfRangeException("ButtonSize", SR.GetString(SR.InvalidArgument, "ButtonSize", value.ToString()));
if (buttonSize != value) {
buttonSize = value;
maxWidth = -1; // Force recompute of maxWidth
RecreateHandle();
AdjustSize(Dock);
}
}
}
///
/// Returns the parameters needed to create the handle. Inheriting classes
/// can override this to provide extra functionality. They should not,
/// however, forget to get base.CreateParams first to get the struct
/// filled up with the basic info.
///
///
/// Deriving classes can override this to configure a default size for their control.
/// This is more efficient than setting the size in the control's constructor.
///
protected override Size DefaultSize {
get {
return new Size(100, 22);
}
}
///
/// Gets or sets a value indicating
/// whether the toolbar displays a divider.
///
[
SRCategory(SR.CatAppearance),
DefaultValue(true),
SRDescription(SR.ToolBarDividerDescr)
]
public bool Divider {
get {
return toolBarState[TOOLBARSTATE_divider];
}
set {
if (Divider != value) {
toolBarState[TOOLBARSTATE_divider] = value;
RecreateHandle();
}
}
}
///
///
/// Sets the way in which this ToolBar is docked to its parent. We need to
/// override this to ensure autoSizing works correctly
///
///
[
Localizable(true),
DefaultValue(DockStyle.Top)
]
public override DockStyle Dock {
get { return base.Dock;}
set {
//valid values are 0x0 to 0x5
if (!ClientUtils.IsEnumValid(value, (int)value, (int)DockStyle.None, (int)DockStyle.Fill)){
throw new InvalidEnumArgumentException("value", (int)value, typeof(DockStyle));
}
if (Dock != value) {
if (value == DockStyle.Left || value == DockStyle.Right) {
SetStyle(ControlStyles.FixedWidth, AutoSize);
SetStyle(ControlStyles.FixedHeight, false);
}
else {
SetStyle(ControlStyles.FixedHeight, AutoSize);
SetStyle(ControlStyles.FixedWidth, false);
}
AdjustSize(value);
base.Dock = value;
}
}
}
///
/// This property is overridden and hidden from statement completion
/// on controls that are based on Win32 Native Controls.
///
[EditorBrowsable(EditorBrowsableState.Never)]
protected override bool DoubleBuffered {
get {
return base.DoubleBuffered;
}
set {
base.DoubleBuffered = value;
}
}
///
/// Gets or sets a value indicating whether drop-down buttons on a
/// toolbar display down arrows.
///
[
DefaultValue(false),
SRCategory(SR.CatAppearance),
Localizable(true),
SRDescription(SR.ToolBarDropDownArrowsDescr)
]
public bool DropDownArrows {
get {
return toolBarState[TOOLBARSTATE_dropDownArrows];
}
set {
if (DropDownArrows != value) {
toolBarState[TOOLBARSTATE_dropDownArrows] = value;
RecreateHandle();
}
}
}
///
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override Color ForeColor {
get {
return base.ForeColor;
}
set {
base.ForeColor = value;
}
}
///
/// Gets or sets the collection of images available to the toolbar button
/// controls.
///
[
SRCategory(SR.CatBehavior),
DefaultValue(null),
SRDescription(SR.ToolBarImageListDescr)
]
public ImageList ImageList {
get {
return this.imageList;
}
set {
if (value != imageList) {
EventHandler recreateHandler = new EventHandler(ImageListRecreateHandle);
EventHandler disposedHandler = new EventHandler(DetachImageList);
if (imageList != null) {
imageList.Disposed -= disposedHandler;
imageList.RecreateHandle -= recreateHandler;
}
imageList = value;
if (value != null) {
value.Disposed += disposedHandler;
value.RecreateHandle += recreateHandler;
}
if (IsHandleCreated)
RecreateHandle();
}
}
}
///
/// Gets the size of the images in the image list assigned to the
/// toolbar.
///
[
SRCategory(SR.CatBehavior),
Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
SRDescription(SR.ToolBarImageSizeDescr)
]
public Size ImageSize {
get {
if (this.imageList != null) {
return this.imageList.ImageSize;
}
else {
return new Size(0, 0);
}
}
}
///
/// The preferred height for this ToolBar control. This is
/// used by the AutoSizing code.
///
internal int PreferredHeight {
get {
int height = 0;
if (buttons == null || buttonCount == 0 || !IsHandleCreated) {
height = ButtonSize.Height;
}
else {
// get the first visible button and get it's height
//
NativeMethods.RECT rect = new NativeMethods.RECT();
int firstVisible;
for (firstVisible = 0; firstVisible < buttons.Length; firstVisible++) {
if (buttons[firstVisible] != null && buttons[firstVisible].Visible) {
break;
}
}
if (firstVisible == buttons.Length) {
firstVisible = 0;
}
SendMessage(NativeMethods.TB_GETRECT, firstVisible, ref rect);
// height is the button's height plus some extra goo
//
height = rect.bottom - rect.top;
}
// if the ToolBar is wrappable, and there is more than one row, make
// sure the height is correctly adjusted
//
if (Wrappable && IsHandleCreated) {
height = height * (int)SendMessage(NativeMethods.TB_GETROWS, 0, 0);
}
height = (height > 0) ? height : 1;
switch(borderStyle) {
case BorderStyle.FixedSingle:
height += SystemInformation.BorderSize.Height;
break;
case BorderStyle.Fixed3D:
height += SystemInformation.Border3DSize.Height;
break;
}
if (Divider) height += 2;
height += 4;
return height;
}
}
///
/// The preferred width for this ToolBar control. This is
/// used by AutoSizing code.
/// NOTE!!!!!!!!! This function assumes it's only going to get called
/// if the control is docked left or right [ie, it really
/// just returns a max width]
///
internal int PreferredWidth {
get {
int width;
// fortunately, we compute this value sometimes, so we can just
// use it if we have it.
//
if (maxWidth == -1) {
// don't have it, have to recompute
//
if (!IsHandleCreated || buttons == null)
maxWidth = ButtonSize.Width;
else {
NativeMethods.RECT rect = new NativeMethods.RECT();
for (int x = 0; x < buttonCount; x++) {
SendMessage(NativeMethods.TB_GETRECT, 0, ref rect);
if ((rect.right - rect.left) > maxWidth)
maxWidth = rect.right - rect.left;
}
}
}
width = maxWidth;
if (borderStyle != BorderStyle.None) {
width += SystemInformation.BorderSize.Height * 4 + 3;
}
return width;
}
}
///
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override RightToLeft RightToLeft {
get {
return base.RightToLeft;
}
set {
base.RightToLeft = value;
}
}
///
/// VSWhidbey 219660: We need to track the current scale factor so that we can tell the
/// unmanaged control how to scale its buttons.
///
///
/// VSWhidbey 219660: We need to track the current scale factor so that we can tell the
/// unmanaged control how to scale its buttons.
///
protected override void ScaleControl(SizeF factor, BoundsSpecified specified) {
currentScaleDX = factor.Width;
currentScaleDY = factor.Height;
base.ScaleControl(factor, specified);
}
///
///
/// Gets or sets a value indicating whether the toolbar displays a
/// tool tip for each button.
///
[
SRCategory(SR.CatBehavior),
DefaultValue(false),
Localizable(true),
SRDescription(SR.ToolBarShowToolTipsDescr)
]
public bool ShowToolTips {
get {
return toolBarState[TOOLBARSTATE_showToolTips];
}
set {
if (ShowToolTips != value) {
toolBarState[TOOLBARSTATE_showToolTips] = value;
RecreateHandle();
}
}
}
///
///
[DefaultValue(false)]
new public bool TabStop {
get {
return base.TabStop;
}
set {
base.TabStop = value;
}
}
///
///
[
Browsable(false), EditorBrowsable(EditorBrowsableState.Never),
Bindable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public override string Text {
get {
return base.Text;
}
set {
base.Text = value;
}
}
///
/// Gets or sets the alignment of text in relation to each
/// image displayed on
/// the toolbar button controls.
///
[
SRCategory(SR.CatAppearance),
DefaultValue(ToolBarTextAlign.Underneath),
Localizable(true),
SRDescription(SR.ToolBarTextAlignDescr)
]
public ToolBarTextAlign TextAlign {
get {
return textAlign;
}
set {
//valid values are 0x0 to 0x1
if (!ClientUtils.IsEnumValid(value, (int)value, (int)ToolBarTextAlign.Underneath, (int)ToolBarTextAlign.Right)) {
throw new InvalidEnumArgumentException("value", (int)value, typeof(ToolBarTextAlign));
}
if (textAlign == value) return;
textAlign = value;
RecreateHandle();
}
}
///
/// Gets
/// or sets a value
/// indicating whether the toolbar buttons wrap to the next line if the
/// toolbar becomes too small to display all the buttons
/// on the same line.
///
[
SRCategory(SR.CatBehavior),
DefaultValue(true),
Localizable(true),
SRDescription(SR.ToolBarWrappableDescr)
]
public bool Wrappable {
get {
return toolBarState[TOOLBARSTATE_wrappable];
}
set {
if (Wrappable != value) {
toolBarState[TOOLBARSTATE_wrappable] = value;
RecreateHandle();
}
}
}
///
/// Occurs when a
///
[SRCategory(SR.CatBehavior), SRDescription(SR.ToolBarButtonClickDescr)]
public event ToolBarButtonClickEventHandler ButtonClick {
add {
onButtonClick += value;
}
remove {
onButtonClick -= value;
}
}
///
/// Occurs when a drop-down style
///
[SRCategory(SR.CatBehavior), SRDescription(SR.ToolBarButtonDropDownDescr)]
public event ToolBarButtonClickEventHandler ButtonDropDown {
add {
onButtonDropDown += value;
}
remove {
onButtonDropDown -= value;
}
}
///
/// ToolBar Onpaint.
///
///
/// Adjusts the height or width of the ToolBar to make sure we have enough
/// room to show the buttons.
///
///
/// This routine lets us change a bunch of things about the toolbar without
/// having each operation wait for the paint to complete. This must be
/// matched up with a call to endUpdate().
///
internal void BeginUpdate() {
BeginUpdateInternal();
}
///
///
///
/// Resets the imageList to null. We wire this method up to the imageList's
/// Dispose event, so that we don't hang onto an imageList that's gone away.
///
private void DetachImageList(object sender, EventArgs e) {
ImageList = null;
}
///
///
///
/// This routine lets us change a bunch of things about the toolbar without
/// having each operation wait for the paint to complete. This must be
/// matched up with a call to beginUpdate().
///
internal void EndUpdate() {
EndUpdateInternal();
}
///
/// Forces the button sizes based on various different things. The default
/// ToolBar button sizing rules are pretty primitive and this tends to be
/// a little better, and lets us actually show things like DropDown Arrows
/// for ToolBars
///
///
///
private void Insert(int index, ToolBarButton button) {
button.parent = this;
if (buttons == null) {
buttons = new ToolBarButton[4];
}
else if (buttons.Length == buttonCount) {
ToolBarButton[] newButtons = new ToolBarButton[buttonCount + 4];
System.Array.Copy(buttons, 0, newButtons, 0, buttonCount);
buttons = newButtons;
}
if (index < buttonCount)
System.Array.Copy(buttons, index, buttons, index + 1, buttonCount - index);
buttons[index] = button;
buttonCount++;
}
///
/// Inserts a button at a given location on the toolbar control.
///
private void InsertButton(int index, ToolBarButton value) {
if (value == null)
throw new ArgumentNullException("value");
if (index < 0 || ((buttons != null) && (index > buttonCount)))
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
// insert the button into our local array, and then into the
// real windows ToolBar control
//
Insert(index, value);
if (IsHandleCreated) {
NativeMethods.TBBUTTON tbbutton = value.GetTBBUTTON(index);
UnsafeNativeMethods.SendMessage(new HandleRef(this, Handle), NativeMethods.TB_INSERTBUTTON, index, ref tbbutton);
}
UpdateButtons();
}
///
/// Adds a button to the ToolBar
///
///
/// Changes the data for a button in the ToolBar, and then does the appropriate
/// work to update the ToolBar control.
///
///
/// Raises the
///
protected virtual void OnButtonClick(ToolBarButtonClickEventArgs e) {
if (onButtonClick != null) onButtonClick(this, e);
}
///
/// Raises the
///
protected virtual void OnButtonDropDown(ToolBarButtonClickEventArgs e) {
if (onButtonDropDown != null) onButtonDropDown(this, e);
}
///
///
/// Overridden from the control class so we can add all the buttons
/// and do whatever work needs to be done.
/// Don't forget to call base.OnHandleCreated.
///
///
protected override void OnHandleCreated(EventArgs e) {
base.OnHandleCreated(e);
// we have to set the button struct size, because they don't.
//
SendMessage(NativeMethods.TB_BUTTONSTRUCTSIZE, Marshal.SizeOf(typeof(NativeMethods.TBBUTTON)), 0);
// set up some extra goo
//
if (DropDownArrows)
SendMessage(NativeMethods.TB_SETEXTENDEDSTYLE, 0, NativeMethods.TBSTYLE_EX_DRAWDDARROWS);
// if we have an imagelist, add it in now.
//
if (imageList != null)
SendMessage(NativeMethods.TB_SETIMAGELIST, 0, imageList.Handle);
RealizeButtons();
// Force a repaint, as occasionally the ToolBar border does not paint properly
// (comctl ToolBar is flaky)
//
BeginUpdate();
try {
Size size = Size;
Size = new Size(size.Width + 1, size.Height);
Size = size;
}
finally {
EndUpdate();
}
}
///
///
/// The control is being resized. Make sure the width/height are correct.
///
///
protected override void OnResize(EventArgs e) {
base.OnResize(e);
if (Wrappable) AdjustSize(Dock);
}
///
///
/// Overridden to ensure that the buttons and the control resize properly
/// whenever the font changes.
///
///
protected override void OnFontChanged(EventArgs e) {
base.OnFontChanged(e);
if (IsHandleCreated) {
if (!buttonSize.IsEmpty) {
SendToolbarButtonSizeMessage();
}
else {
AdjustSize(Dock);
ForceButtonWidths();
}
}
}
///
/// Sets all the button data into the ToolBar control
///
///
///
private void RemoveAt(int index) {
buttons[index].parent = null;
buttons[index].stringIndex = (IntPtr)(-1);
buttonCount--;
if (index < buttonCount)
System.Array.Copy(buttons, index + 1, buttons, index, buttonCount - index);
buttons[buttonCount] = null;
}
///
/// Resets the toolbar buttons to the minimum
/// size.
///
private void ResetButtonSize() {
buttonSize = Size.Empty;
RecreateHandle();
}
/// Sends a TB_SETBUTTONSIZE message to the unmanaged control, with size arguments properly scaled.
private void SendToolbarButtonSizeMessage() {
SendMessage(NativeMethods.TB_SETBUTTONSIZE, 0, NativeMethods.Util.MAKELPARAM((int)(buttonSize.Width*currentScaleDX), (int)(buttonSize.Height*currentScaleDY)));
}
///
/// Overrides Control.setBoundsCore to enforce AutoSize.
///
///
/// Determines if the
///
private bool ShouldSerializeButtonSize() {
return !buttonSize.IsEmpty;
}
///
/// Called by ToolTip to poke in that Tooltip into this ComCtl so that the Native ChildToolTip is not exposed.
///
///
/// Returns a string representation for this control.
///
///
/// Updates all the information in the ToolBar. Tragically, the win32
/// control is pretty flakey, and the only real choice here is to recreate
/// the handle and re-realize all the buttons.
///
///
/// The button clicked was a dropdown button. If it has a menu specified,
/// show it now. Otherwise, fire an onButtonDropDown event.
///
///
///
///
///
///
/// Encapsulates a collection of
///
public class ToolBarButtonCollection : IList {
private ToolBar owner;
private bool suspendUpdate;
/// A caching mechanism for key accessor
/// We use an index here rather than control so that we don't have lifetime
/// issues by holding on to extra references.
private int lastAccessedIndex = -1;
///
/// Initializes a new instance of the
///
public ToolBarButtonCollection(ToolBar owner) {
this.owner = owner;
}
///
/// Gets or sets the toolbar button at the specified indexed location in the
/// toolbar button collection.
///
public virtual ToolBarButton this[int index] {
get {
if (index < 0 || ((owner.buttons != null) && (index >= owner.buttonCount)))
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
return owner.buttons[index];
}
set {
// Sanity check parameters
//
if (index < 0 || ((owner.buttons != null) && index >= owner.buttonCount)) {
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
}
if (value == null) {
throw new ArgumentNullException("value");
}
owner.InternalSetButton(index, value, true, true);
}
}
///
/// Retrieves the child control with the specified key.
///
public virtual ToolBarButton this[string key] {
get {
// We do not support null and empty string as valid keys.
if (string.IsNullOrEmpty(key)){
return null;
}
// Search for the key in our collection
int index = IndexOfKey(key);
if (IsValidIndex(index)) {
return this[index];
}
else {
return null;
}
}
}
///
/// Gets the number of buttons in the toolbar button collection.
///
[Browsable(false)]
public int Count {
get {
return owner.buttonCount;
}
}
///
/// [To be supplied.]
///
public bool IsReadOnly {
get {
return false;
}
}
///
/// Adds a new toolbar button to
/// the end of the toolbar button collection.
///
public int Add(ToolBarButton button) {
int index = owner.InternalAddButton(button);
if (!suspendUpdate) {
owner.UpdateButtons();
}
return index;
}
///
/// [To be supplied.]
///
public int Add(string text) {
ToolBarButton button = new ToolBarButton(text);
return Add(button);
}
///
/// [To be supplied.]
///
public void AddRange(ToolBarButton[] buttons) {
if (buttons == null) {
throw new ArgumentNullException("buttons");
}
try {
suspendUpdate = true;
foreach(ToolBarButton button in buttons) {
Add(button);
}
}
finally {
suspendUpdate = false;
owner.UpdateButtons();
}
}
///
/// Removes
/// all buttons from the toolbar button collection.
///
public void Clear() {
if (owner.buttons == null) {
return;
}
for (int x = owner.buttonCount; x > 0; x--) {
if (owner.IsHandleCreated) {
owner.SendMessage(NativeMethods.TB_DELETEBUTTON, x - 1, 0);
}
owner.RemoveAt(x - 1);
}
owner.buttons = null;
owner.buttonCount = 0;
if (!owner.Disposing) {
owner.UpdateButtons();
}
}
///
/// [To be supplied.]
///
public bool Contains(ToolBarButton button) {
return IndexOf(button) != -1;
}
///
/// Returns true if the collection contains an item with the specified key, false otherwise.
///
public virtual bool ContainsKey(string key) {
return IsValidIndex(IndexOfKey(key));
}
///
/// [To be supplied.]
///
public int IndexOf(ToolBarButton button) {
for(int index=0; index < Count; ++index) {
if (this[index] == button) {
return index;
}
}
return -1;
}
///
/// The zero-based index of the first occurrence of value within the entire CollectionBase, if found; otherwise, -1.
///
public virtual int IndexOfKey(String key) {
// Step 0 - Arg validation
if (string.IsNullOrEmpty(key)){
return -1; // we dont support empty or null keys.
}
// step 1 - check the last cached item
if (IsValidIndex(lastAccessedIndex))
{
if (WindowsFormsUtils.SafeCompareStrings(this[lastAccessedIndex].Name, key, /* ignoreCase = */ true)) {
return lastAccessedIndex;
}
}
// step 2 - search for the item
for (int i = 0; i < this.Count; i ++) {
if (WindowsFormsUtils.SafeCompareStrings(this[i].Name, key, /* ignoreCase = */ true)) {
lastAccessedIndex = i;
return i;
}
}
// step 3 - we didn't find it. Invalidate the last accessed index and return -1.
lastAccessedIndex = -1;
return -1;
}
///
/// [To be supplied.]
///
public void Insert(int index, ToolBarButton button) {
owner.InsertButton(index, button);
}
///
/// Determines if the index is valid for the collection.
///
///
/// Removes
/// a given button from the toolbar button collection.
///
public void RemoveAt(int index) {
int count = (owner.buttons == null) ? 0 : owner.buttonCount;
if (index < 0 || index >= count)
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
if (owner.IsHandleCreated) {
owner.SendMessage(NativeMethods.TB_DELETEBUTTON, index, 0);
}
owner.RemoveAt(index);
owner.UpdateButtons();
}
///
/// Removes the child control with the specified key.
///
public virtual void RemoveByKey(string key) {
int index = IndexOfKey(key);
if (IsValidIndex(index)) {
RemoveAt(index);
}
}
///
/// [To be supplied.]
///
public void Remove(ToolBarButton button) {
int index = IndexOf(button);
if (index != -1) {
RemoveAt(index);
}
}
///
/// Returns an enumerator that can be used to iterate
/// through the toolbar button collection.
///
public IEnumerator GetEnumerator() {
return new WindowsFormsUtils.ArraySubsetEnumerator(owner.buttons, owner.buttonCount);
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
namespace System.Windows.Forms {
using System.Runtime.Serialization.Formatters;
using System.Runtime.Remoting;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Diagnostics;
using System;
using System.Security.Permissions;
using System.Drawing;
using System.Collections;
using System.ComponentModel.Design;
using Microsoft.Win32;
using System.Globalization;
///
/// Represents a Windows toolbar.
///
[
ComVisible(true),
ClassInterface(ClassInterfaceType.AutoDispatch),
DefaultEvent("ButtonClick"),
Designer("System.Windows.Forms.Design.ToolBarDesigner, " + AssemblyRef.SystemDesign),
DefaultProperty("Buttons")
]
public class ToolBar : Control {
private ToolBarButtonCollection buttonsCollection;
///
/// The size of a button in the ToolBar
///
internal Size buttonSize = System.Drawing.Size.Empty;
///
/// This is used by our autoSizing support.
///
private int requestedSize;
///
/// This represents the width of the drop down arrow we have if the
/// DropDownArrows property is true. this value is used by the ToolBarButton
/// objects to compute their size
///
internal const int DDARROW_WIDTH = 15;
///
/// Indicates what our appearance will be. This will either be normal
/// or flat.
///
private ToolBarAppearance appearance = ToolBarAppearance.Normal;
///
/// Indicates whether or not we have a border
///
private BorderStyle borderStyle = System.Windows.Forms.BorderStyle.None;
///
/// The array of buttons we're working with.
///
private ToolBarButton [] buttons;
///
/// The number of buttons we're working with
///
private int buttonCount = 0;
///
/// Indicates if text captions should go underneath images in buttons or
/// to the right of them
///
private ToolBarTextAlign textAlign = ToolBarTextAlign.Underneath;
///
/// The ImageList object that contains the main images for our control.
///
private ImageList imageList = null;
///
/// The maximum width of buttons currently being displayed. This is needed
/// by our autoSizing code. If this value is -1, it needs to be recomputed.
///
private int maxWidth = -1;
///
/// To be supplied.
///
private int hotItem = -1;
// VSWhidbey 219660: Track the current scale factor so we can scale our buttons
private float currentScaleDX = 1.0F;
private float currentScaleDY = 1.0F;
private const int TOOLBARSTATE_wrappable = 0x00000001;
private const int TOOLBARSTATE_dropDownArrows = 0x00000002;
private const int TOOLBARSTATE_divider = 0x00000004;
private const int TOOLBARSTATE_showToolTips = 0x00000008;
private const int TOOLBARSTATE_autoSize = 0x00000010;
// PERF: take all the bools and put them into a state variable
private System.Collections.Specialized.BitVector32 toolBarState; // see TOOLBARSTATE_ consts above
// event handlers
//
private ToolBarButtonClickEventHandler onButtonClick = null;
private ToolBarButtonClickEventHandler onButtonDropDown = null;
///
/// Initializes a new instance of the
///
public ToolBar()
: base() {
// Set this BEFORE calling any other methods so that these defaults will be propagated
toolBarState = new System.Collections.Specialized.BitVector32(TOOLBARSTATE_autoSize |
TOOLBARSTATE_showToolTips |
TOOLBARSTATE_divider |
TOOLBARSTATE_dropDownArrows |
TOOLBARSTATE_wrappable);
SetStyle(ControlStyles.UserPaint, false);
SetStyle(ControlStyles.FixedHeight, AutoSize);
SetStyle(ControlStyles.FixedWidth, false);
TabStop = false;
Dock = DockStyle.Top;
buttonsCollection = new ToolBarButtonCollection(this);
}
///
/// Gets or sets the appearance of the toolbar
/// control and its buttons.
///
[
SRCategory(SR.CatBehavior),
DefaultValue(ToolBarAppearance.Normal),
Localizable(true),
SRDescription(SR.ToolBarAppearanceDescr)
]
public ToolBarAppearance Appearance {
get {
return appearance;
}
set {
//valid values are 0x0 to 0x1
if (!ClientUtils.IsEnumValid(value, (int)value, (int)ToolBarAppearance.Normal, (int)ToolBarAppearance.Flat)){
throw new InvalidEnumArgumentException("value", (int)value, typeof(ToolBarAppearance));
}
if (value != appearance) {
appearance = value;
RecreateHandle();
}
}
}
///
/// Indicates whether the toolbar
/// adjusts its size automatically based on the size of the buttons and the
/// dock style.
///
[
SRCategory(SR.CatBehavior),
DefaultValue(true),
Localizable(true),
SRDescription(SR.ToolBarAutoSizeDescr),
Browsable(true),
EditorBrowsable(EditorBrowsableState.Always),
DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)
]
public override bool AutoSize {
get {
return toolBarState[TOOLBARSTATE_autoSize];
}
set {
// Note that we intentionally do not call base. Toolbars size themselves by
// overriding SetBoundsCore (old RTM code). We let CommonProperties.GetAutoSize
// continue to return false to keep our LayoutEngines from messing with TextBoxes.
// This is done for backwards compatibility since the new AutoSize behavior differs.
if (AutoSize != value) {
toolBarState[TOOLBARSTATE_autoSize] = value;
if (Dock == DockStyle.Left || Dock == DockStyle.Right) {
SetStyle(ControlStyles.FixedWidth, AutoSize);
SetStyle(ControlStyles.FixedHeight, false);
}
else {
SetStyle(ControlStyles.FixedHeight, AutoSize);
SetStyle(ControlStyles.FixedWidth, false);
}
AdjustSize(Dock);
OnAutoSizeChanged(EventArgs.Empty);
}
}
}
///
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override Color BackColor {
get {
return base.BackColor;
}
set {
base.BackColor = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override Image BackgroundImage {
get {
return base.BackgroundImage;
}
set {
base.BackgroundImage = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override ImageLayout BackgroundImageLayout {
get {
return base.BackgroundImageLayout;
}
set {
base.BackgroundImageLayout = value;
}
}
///
/// Gets or sets
/// the border style of the toolbar control.
///
[
SRCategory(SR.CatAppearance),
DefaultValue(BorderStyle.None),
DispId(NativeMethods.ActiveX.DISPID_BORDERSTYLE),
SRDescription(SR.ToolBarBorderStyleDescr)
]
public BorderStyle BorderStyle {
get {
return borderStyle;
}
set {
//valid values are 0x0 to 0x2
if (!ClientUtils.IsEnumValid(value, (int)value, (int)BorderStyle.None, (int)BorderStyle.Fixed3D)){
throw new InvalidEnumArgumentException("value", (int)value, typeof(BorderStyle));
}
if (borderStyle != value) {
borderStyle = value;
//UpdateStyles();
RecreateHandle(); // Looks like we need to recreate the handle to avoid painting glitches
}
}
}
///
/// A collection of
///
[
SRCategory(SR.CatBehavior),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
Localizable(true),
SRDescription(SR.ToolBarButtonsDescr),
MergableProperty(false)
]
public ToolBarButtonCollection Buttons {
get {
return buttonsCollection;
}
}
///
/// Gets or sets
/// the size of the buttons on the toolbar control.
///
[
SRCategory(SR.CatAppearance),
RefreshProperties(RefreshProperties.All),
Localizable(true),
SRDescription(SR.ToolBarButtonSizeDescr)
]
public Size ButtonSize {
get {
if (buttonSize.IsEmpty) {
// Obtain the current buttonsize of the first button from the winctl control
//
if (IsHandleCreated && buttons != null && buttonCount > 0) {
int result = (int)SendMessage(NativeMethods.TB_GETBUTTONSIZE, 0, 0);
if (result > 0) {
return new Size(NativeMethods.Util.LOWORD(result), NativeMethods.Util.HIWORD(result));
}
}
if (TextAlign == ToolBarTextAlign.Underneath) {
return new Size(39, 36); // Default button size
}
else {
return new Size(23, 22); // Default button size
}
}
else {
return buttonSize;
}
}
set {
if (value.Width < 0 || value.Height < 0)
throw new ArgumentOutOfRangeException("ButtonSize", SR.GetString(SR.InvalidArgument, "ButtonSize", value.ToString()));
if (buttonSize != value) {
buttonSize = value;
maxWidth = -1; // Force recompute of maxWidth
RecreateHandle();
AdjustSize(Dock);
}
}
}
///
/// Returns the parameters needed to create the handle. Inheriting classes
/// can override this to provide extra functionality. They should not,
/// however, forget to get base.CreateParams first to get the struct
/// filled up with the basic info.
///
///
/// Deriving classes can override this to configure a default size for their control.
/// This is more efficient than setting the size in the control's constructor.
///
protected override Size DefaultSize {
get {
return new Size(100, 22);
}
}
///
/// Gets or sets a value indicating
/// whether the toolbar displays a divider.
///
[
SRCategory(SR.CatAppearance),
DefaultValue(true),
SRDescription(SR.ToolBarDividerDescr)
]
public bool Divider {
get {
return toolBarState[TOOLBARSTATE_divider];
}
set {
if (Divider != value) {
toolBarState[TOOLBARSTATE_divider] = value;
RecreateHandle();
}
}
}
///
///
/// Sets the way in which this ToolBar is docked to its parent. We need to
/// override this to ensure autoSizing works correctly
///
///
[
Localizable(true),
DefaultValue(DockStyle.Top)
]
public override DockStyle Dock {
get { return base.Dock;}
set {
//valid values are 0x0 to 0x5
if (!ClientUtils.IsEnumValid(value, (int)value, (int)DockStyle.None, (int)DockStyle.Fill)){
throw new InvalidEnumArgumentException("value", (int)value, typeof(DockStyle));
}
if (Dock != value) {
if (value == DockStyle.Left || value == DockStyle.Right) {
SetStyle(ControlStyles.FixedWidth, AutoSize);
SetStyle(ControlStyles.FixedHeight, false);
}
else {
SetStyle(ControlStyles.FixedHeight, AutoSize);
SetStyle(ControlStyles.FixedWidth, false);
}
AdjustSize(value);
base.Dock = value;
}
}
}
///
/// This property is overridden and hidden from statement completion
/// on controls that are based on Win32 Native Controls.
///
[EditorBrowsable(EditorBrowsableState.Never)]
protected override bool DoubleBuffered {
get {
return base.DoubleBuffered;
}
set {
base.DoubleBuffered = value;
}
}
///
/// Gets or sets a value indicating whether drop-down buttons on a
/// toolbar display down arrows.
///
[
DefaultValue(false),
SRCategory(SR.CatAppearance),
Localizable(true),
SRDescription(SR.ToolBarDropDownArrowsDescr)
]
public bool DropDownArrows {
get {
return toolBarState[TOOLBARSTATE_dropDownArrows];
}
set {
if (DropDownArrows != value) {
toolBarState[TOOLBARSTATE_dropDownArrows] = value;
RecreateHandle();
}
}
}
///
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override Color ForeColor {
get {
return base.ForeColor;
}
set {
base.ForeColor = value;
}
}
///
/// Gets or sets the collection of images available to the toolbar button
/// controls.
///
[
SRCategory(SR.CatBehavior),
DefaultValue(null),
SRDescription(SR.ToolBarImageListDescr)
]
public ImageList ImageList {
get {
return this.imageList;
}
set {
if (value != imageList) {
EventHandler recreateHandler = new EventHandler(ImageListRecreateHandle);
EventHandler disposedHandler = new EventHandler(DetachImageList);
if (imageList != null) {
imageList.Disposed -= disposedHandler;
imageList.RecreateHandle -= recreateHandler;
}
imageList = value;
if (value != null) {
value.Disposed += disposedHandler;
value.RecreateHandle += recreateHandler;
}
if (IsHandleCreated)
RecreateHandle();
}
}
}
///
/// Gets the size of the images in the image list assigned to the
/// toolbar.
///
[
SRCategory(SR.CatBehavior),
Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
SRDescription(SR.ToolBarImageSizeDescr)
]
public Size ImageSize {
get {
if (this.imageList != null) {
return this.imageList.ImageSize;
}
else {
return new Size(0, 0);
}
}
}
///
/// The preferred height for this ToolBar control. This is
/// used by the AutoSizing code.
///
internal int PreferredHeight {
get {
int height = 0;
if (buttons == null || buttonCount == 0 || !IsHandleCreated) {
height = ButtonSize.Height;
}
else {
// get the first visible button and get it's height
//
NativeMethods.RECT rect = new NativeMethods.RECT();
int firstVisible;
for (firstVisible = 0; firstVisible < buttons.Length; firstVisible++) {
if (buttons[firstVisible] != null && buttons[firstVisible].Visible) {
break;
}
}
if (firstVisible == buttons.Length) {
firstVisible = 0;
}
SendMessage(NativeMethods.TB_GETRECT, firstVisible, ref rect);
// height is the button's height plus some extra goo
//
height = rect.bottom - rect.top;
}
// if the ToolBar is wrappable, and there is more than one row, make
// sure the height is correctly adjusted
//
if (Wrappable && IsHandleCreated) {
height = height * (int)SendMessage(NativeMethods.TB_GETROWS, 0, 0);
}
height = (height > 0) ? height : 1;
switch(borderStyle) {
case BorderStyle.FixedSingle:
height += SystemInformation.BorderSize.Height;
break;
case BorderStyle.Fixed3D:
height += SystemInformation.Border3DSize.Height;
break;
}
if (Divider) height += 2;
height += 4;
return height;
}
}
///
/// The preferred width for this ToolBar control. This is
/// used by AutoSizing code.
/// NOTE!!!!!!!!! This function assumes it's only going to get called
/// if the control is docked left or right [ie, it really
/// just returns a max width]
///
internal int PreferredWidth {
get {
int width;
// fortunately, we compute this value sometimes, so we can just
// use it if we have it.
//
if (maxWidth == -1) {
// don't have it, have to recompute
//
if (!IsHandleCreated || buttons == null)
maxWidth = ButtonSize.Width;
else {
NativeMethods.RECT rect = new NativeMethods.RECT();
for (int x = 0; x < buttonCount; x++) {
SendMessage(NativeMethods.TB_GETRECT, 0, ref rect);
if ((rect.right - rect.left) > maxWidth)
maxWidth = rect.right - rect.left;
}
}
}
width = maxWidth;
if (borderStyle != BorderStyle.None) {
width += SystemInformation.BorderSize.Height * 4 + 3;
}
return width;
}
}
///
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override RightToLeft RightToLeft {
get {
return base.RightToLeft;
}
set {
base.RightToLeft = value;
}
}
///
/// VSWhidbey 219660: We need to track the current scale factor so that we can tell the
/// unmanaged control how to scale its buttons.
///
///
/// VSWhidbey 219660: We need to track the current scale factor so that we can tell the
/// unmanaged control how to scale its buttons.
///
protected override void ScaleControl(SizeF factor, BoundsSpecified specified) {
currentScaleDX = factor.Width;
currentScaleDY = factor.Height;
base.ScaleControl(factor, specified);
}
///
///
/// Gets or sets a value indicating whether the toolbar displays a
/// tool tip for each button.
///
[
SRCategory(SR.CatBehavior),
DefaultValue(false),
Localizable(true),
SRDescription(SR.ToolBarShowToolTipsDescr)
]
public bool ShowToolTips {
get {
return toolBarState[TOOLBARSTATE_showToolTips];
}
set {
if (ShowToolTips != value) {
toolBarState[TOOLBARSTATE_showToolTips] = value;
RecreateHandle();
}
}
}
///
///
[DefaultValue(false)]
new public bool TabStop {
get {
return base.TabStop;
}
set {
base.TabStop = value;
}
}
///
///
[
Browsable(false), EditorBrowsable(EditorBrowsableState.Never),
Bindable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public override string Text {
get {
return base.Text;
}
set {
base.Text = value;
}
}
///
/// Gets or sets the alignment of text in relation to each
/// image displayed on
/// the toolbar button controls.
///
[
SRCategory(SR.CatAppearance),
DefaultValue(ToolBarTextAlign.Underneath),
Localizable(true),
SRDescription(SR.ToolBarTextAlignDescr)
]
public ToolBarTextAlign TextAlign {
get {
return textAlign;
}
set {
//valid values are 0x0 to 0x1
if (!ClientUtils.IsEnumValid(value, (int)value, (int)ToolBarTextAlign.Underneath, (int)ToolBarTextAlign.Right)) {
throw new InvalidEnumArgumentException("value", (int)value, typeof(ToolBarTextAlign));
}
if (textAlign == value) return;
textAlign = value;
RecreateHandle();
}
}
///
/// Gets
/// or sets a value
/// indicating whether the toolbar buttons wrap to the next line if the
/// toolbar becomes too small to display all the buttons
/// on the same line.
///
[
SRCategory(SR.CatBehavior),
DefaultValue(true),
Localizable(true),
SRDescription(SR.ToolBarWrappableDescr)
]
public bool Wrappable {
get {
return toolBarState[TOOLBARSTATE_wrappable];
}
set {
if (Wrappable != value) {
toolBarState[TOOLBARSTATE_wrappable] = value;
RecreateHandle();
}
}
}
///
/// Occurs when a
///
[SRCategory(SR.CatBehavior), SRDescription(SR.ToolBarButtonClickDescr)]
public event ToolBarButtonClickEventHandler ButtonClick {
add {
onButtonClick += value;
}
remove {
onButtonClick -= value;
}
}
///
/// Occurs when a drop-down style
///
[SRCategory(SR.CatBehavior), SRDescription(SR.ToolBarButtonDropDownDescr)]
public event ToolBarButtonClickEventHandler ButtonDropDown {
add {
onButtonDropDown += value;
}
remove {
onButtonDropDown -= value;
}
}
///
/// ToolBar Onpaint.
///
///
/// Adjusts the height or width of the ToolBar to make sure we have enough
/// room to show the buttons.
///
///
/// This routine lets us change a bunch of things about the toolbar without
/// having each operation wait for the paint to complete. This must be
/// matched up with a call to endUpdate().
///
internal void BeginUpdate() {
BeginUpdateInternal();
}
///
///
///
/// Resets the imageList to null. We wire this method up to the imageList's
/// Dispose event, so that we don't hang onto an imageList that's gone away.
///
private void DetachImageList(object sender, EventArgs e) {
ImageList = null;
}
///
///
///
/// This routine lets us change a bunch of things about the toolbar without
/// having each operation wait for the paint to complete. This must be
/// matched up with a call to beginUpdate().
///
internal void EndUpdate() {
EndUpdateInternal();
}
///
/// Forces the button sizes based on various different things. The default
/// ToolBar button sizing rules are pretty primitive and this tends to be
/// a little better, and lets us actually show things like DropDown Arrows
/// for ToolBars
///
///
///
private void Insert(int index, ToolBarButton button) {
button.parent = this;
if (buttons == null) {
buttons = new ToolBarButton[4];
}
else if (buttons.Length == buttonCount) {
ToolBarButton[] newButtons = new ToolBarButton[buttonCount + 4];
System.Array.Copy(buttons, 0, newButtons, 0, buttonCount);
buttons = newButtons;
}
if (index < buttonCount)
System.Array.Copy(buttons, index, buttons, index + 1, buttonCount - index);
buttons[index] = button;
buttonCount++;
}
///
/// Inserts a button at a given location on the toolbar control.
///
private void InsertButton(int index, ToolBarButton value) {
if (value == null)
throw new ArgumentNullException("value");
if (index < 0 || ((buttons != null) && (index > buttonCount)))
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
// insert the button into our local array, and then into the
// real windows ToolBar control
//
Insert(index, value);
if (IsHandleCreated) {
NativeMethods.TBBUTTON tbbutton = value.GetTBBUTTON(index);
UnsafeNativeMethods.SendMessage(new HandleRef(this, Handle), NativeMethods.TB_INSERTBUTTON, index, ref tbbutton);
}
UpdateButtons();
}
///
/// Adds a button to the ToolBar
///
///
/// Changes the data for a button in the ToolBar, and then does the appropriate
/// work to update the ToolBar control.
///
///
/// Raises the
///
protected virtual void OnButtonClick(ToolBarButtonClickEventArgs e) {
if (onButtonClick != null) onButtonClick(this, e);
}
///
/// Raises the
///
protected virtual void OnButtonDropDown(ToolBarButtonClickEventArgs e) {
if (onButtonDropDown != null) onButtonDropDown(this, e);
}
///
///
/// Overridden from the control class so we can add all the buttons
/// and do whatever work needs to be done.
/// Don't forget to call base.OnHandleCreated.
///
///
protected override void OnHandleCreated(EventArgs e) {
base.OnHandleCreated(e);
// we have to set the button struct size, because they don't.
//
SendMessage(NativeMethods.TB_BUTTONSTRUCTSIZE, Marshal.SizeOf(typeof(NativeMethods.TBBUTTON)), 0);
// set up some extra goo
//
if (DropDownArrows)
SendMessage(NativeMethods.TB_SETEXTENDEDSTYLE, 0, NativeMethods.TBSTYLE_EX_DRAWDDARROWS);
// if we have an imagelist, add it in now.
//
if (imageList != null)
SendMessage(NativeMethods.TB_SETIMAGELIST, 0, imageList.Handle);
RealizeButtons();
// Force a repaint, as occasionally the ToolBar border does not paint properly
// (comctl ToolBar is flaky)
//
BeginUpdate();
try {
Size size = Size;
Size = new Size(size.Width + 1, size.Height);
Size = size;
}
finally {
EndUpdate();
}
}
///
///
/// The control is being resized. Make sure the width/height are correct.
///
///
protected override void OnResize(EventArgs e) {
base.OnResize(e);
if (Wrappable) AdjustSize(Dock);
}
///
///
/// Overridden to ensure that the buttons and the control resize properly
/// whenever the font changes.
///
///
protected override void OnFontChanged(EventArgs e) {
base.OnFontChanged(e);
if (IsHandleCreated) {
if (!buttonSize.IsEmpty) {
SendToolbarButtonSizeMessage();
}
else {
AdjustSize(Dock);
ForceButtonWidths();
}
}
}
///
/// Sets all the button data into the ToolBar control
///
///
///
private void RemoveAt(int index) {
buttons[index].parent = null;
buttons[index].stringIndex = (IntPtr)(-1);
buttonCount--;
if (index < buttonCount)
System.Array.Copy(buttons, index + 1, buttons, index, buttonCount - index);
buttons[buttonCount] = null;
}
///
/// Resets the toolbar buttons to the minimum
/// size.
///
private void ResetButtonSize() {
buttonSize = Size.Empty;
RecreateHandle();
}
/// Sends a TB_SETBUTTONSIZE message to the unmanaged control, with size arguments properly scaled.
private void SendToolbarButtonSizeMessage() {
SendMessage(NativeMethods.TB_SETBUTTONSIZE, 0, NativeMethods.Util.MAKELPARAM((int)(buttonSize.Width*currentScaleDX), (int)(buttonSize.Height*currentScaleDY)));
}
///
/// Overrides Control.setBoundsCore to enforce AutoSize.
///
///
/// Determines if the
///
private bool ShouldSerializeButtonSize() {
return !buttonSize.IsEmpty;
}
///
/// Called by ToolTip to poke in that Tooltip into this ComCtl so that the Native ChildToolTip is not exposed.
///
///
/// Returns a string representation for this control.
///
///
/// Updates all the information in the ToolBar. Tragically, the win32
/// control is pretty flakey, and the only real choice here is to recreate
/// the handle and re-realize all the buttons.
///
///
/// The button clicked was a dropdown button. If it has a menu specified,
/// show it now. Otherwise, fire an onButtonDropDown event.
///
///
///
///
///
///
/// Encapsulates a collection of
///
public class ToolBarButtonCollection : IList {
private ToolBar owner;
private bool suspendUpdate;
/// A caching mechanism for key accessor
/// We use an index here rather than control so that we don't have lifetime
/// issues by holding on to extra references.
private int lastAccessedIndex = -1;
///
/// Initializes a new instance of the
///
public ToolBarButtonCollection(ToolBar owner) {
this.owner = owner;
}
///
/// Gets or sets the toolbar button at the specified indexed location in the
/// toolbar button collection.
///
public virtual ToolBarButton this[int index] {
get {
if (index < 0 || ((owner.buttons != null) && (index >= owner.buttonCount)))
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
return owner.buttons[index];
}
set {
// Sanity check parameters
//
if (index < 0 || ((owner.buttons != null) && index >= owner.buttonCount)) {
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
}
if (value == null) {
throw new ArgumentNullException("value");
}
owner.InternalSetButton(index, value, true, true);
}
}
///
/// Retrieves the child control with the specified key.
///
public virtual ToolBarButton this[string key] {
get {
// We do not support null and empty string as valid keys.
if (string.IsNullOrEmpty(key)){
return null;
}
// Search for the key in our collection
int index = IndexOfKey(key);
if (IsValidIndex(index)) {
return this[index];
}
else {
return null;
}
}
}
///
/// Gets the number of buttons in the toolbar button collection.
///
[Browsable(false)]
public int Count {
get {
return owner.buttonCount;
}
}
///
/// [To be supplied.]
///
public bool IsReadOnly {
get {
return false;
}
}
///
/// Adds a new toolbar button to
/// the end of the toolbar button collection.
///
public int Add(ToolBarButton button) {
int index = owner.InternalAddButton(button);
if (!suspendUpdate) {
owner.UpdateButtons();
}
return index;
}
///
/// [To be supplied.]
///
public int Add(string text) {
ToolBarButton button = new ToolBarButton(text);
return Add(button);
}
///
/// [To be supplied.]
///
public void AddRange(ToolBarButton[] buttons) {
if (buttons == null) {
throw new ArgumentNullException("buttons");
}
try {
suspendUpdate = true;
foreach(ToolBarButton button in buttons) {
Add(button);
}
}
finally {
suspendUpdate = false;
owner.UpdateButtons();
}
}
///
/// Removes
/// all buttons from the toolbar button collection.
///
public void Clear() {
if (owner.buttons == null) {
return;
}
for (int x = owner.buttonCount; x > 0; x--) {
if (owner.IsHandleCreated) {
owner.SendMessage(NativeMethods.TB_DELETEBUTTON, x - 1, 0);
}
owner.RemoveAt(x - 1);
}
owner.buttons = null;
owner.buttonCount = 0;
if (!owner.Disposing) {
owner.UpdateButtons();
}
}
///
/// [To be supplied.]
///
public bool Contains(ToolBarButton button) {
return IndexOf(button) != -1;
}
///
/// Returns true if the collection contains an item with the specified key, false otherwise.
///
public virtual bool ContainsKey(string key) {
return IsValidIndex(IndexOfKey(key));
}
///
/// [To be supplied.]
///
public int IndexOf(ToolBarButton button) {
for(int index=0; index < Count; ++index) {
if (this[index] == button) {
return index;
}
}
return -1;
}
///
/// The zero-based index of the first occurrence of value within the entire CollectionBase, if found; otherwise, -1.
///
public virtual int IndexOfKey(String key) {
// Step 0 - Arg validation
if (string.IsNullOrEmpty(key)){
return -1; // we dont support empty or null keys.
}
// step 1 - check the last cached item
if (IsValidIndex(lastAccessedIndex))
{
if (WindowsFormsUtils.SafeCompareStrings(this[lastAccessedIndex].Name, key, /* ignoreCase = */ true)) {
return lastAccessedIndex;
}
}
// step 2 - search for the item
for (int i = 0; i < this.Count; i ++) {
if (WindowsFormsUtils.SafeCompareStrings(this[i].Name, key, /* ignoreCase = */ true)) {
lastAccessedIndex = i;
return i;
}
}
// step 3 - we didn't find it. Invalidate the last accessed index and return -1.
lastAccessedIndex = -1;
return -1;
}
///
/// [To be supplied.]
///
public void Insert(int index, ToolBarButton button) {
owner.InsertButton(index, button);
}
///
/// Determines if the index is valid for the collection.
///
///
/// Removes
/// a given button from the toolbar button collection.
///
public void RemoveAt(int index) {
int count = (owner.buttons == null) ? 0 : owner.buttonCount;
if (index < 0 || index >= count)
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
if (owner.IsHandleCreated) {
owner.SendMessage(NativeMethods.TB_DELETEBUTTON, index, 0);
}
owner.RemoveAt(index);
owner.UpdateButtons();
}
///
/// Removes the child control with the specified key.
///
public virtual void RemoveByKey(string key) {
int index = IndexOfKey(key);
if (IsValidIndex(index)) {
RemoveAt(index);
}
}
///
/// [To be supplied.]
///
public void Remove(ToolBarButton button) {
int index = IndexOf(button);
if (index != -1) {
RemoveAt(index);
}
}
///
/// Returns an enumerator that can be used to iterate
/// through the toolbar button collection.
///
public IEnumerator GetEnumerator() {
return new WindowsFormsUtils.ArraySubsetEnumerator(owner.buttons, owner.buttonCount);
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- CompositeActivityValidator.cs
- CompatibleComparer.cs
- HebrewNumber.cs
- Marshal.cs
- VideoDrawing.cs
- TrackBar.cs
- InfoCardService.cs
- Floater.cs
- IDReferencePropertyAttribute.cs
- SchemaType.cs
- CustomCredentialPolicy.cs
- PenContexts.cs
- FactoryId.cs
- DependencyProperty.cs
- EntityDataReader.cs
- FormsAuthenticationTicket.cs
- DataGridToolTip.cs
- ReturnValue.cs
- RectIndependentAnimationStorage.cs
- LineBreak.cs
- EdmFunction.cs
- FlowDocumentPage.cs
- MethodImplAttribute.cs
- WebContext.cs
- CommentEmitter.cs
- UnsafeNativeMethods.cs
- CryptoProvider.cs
- ClientFormsIdentity.cs
- UriExt.cs
- GridViewUpdateEventArgs.cs
- MailDefinition.cs
- COSERVERINFO.cs
- TypeElementCollection.cs
- Point.cs
- ConnectionPoint.cs
- PeerApplication.cs
- MapPathBasedVirtualPathProvider.cs
- IpcChannel.cs
- SmtpCommands.cs
- KnowledgeBase.cs
- AppDomainShutdownMonitor.cs
- precedingquery.cs
- GeneralTransformGroup.cs
- PathFigureCollectionConverter.cs
- ListViewGroupItemCollection.cs
- ResumeStoryboard.cs
- CharacterShapingProperties.cs
- SelectedCellsCollection.cs
- EntityTransaction.cs
- EventLogSession.cs
- namescope.cs
- AsymmetricKeyExchangeDeformatter.cs
- PartialCachingControl.cs
- ToolZone.cs
- ThreadInterruptedException.cs
- DockPattern.cs
- ForeignKeyFactory.cs
- FilterQuery.cs
- MatrixUtil.cs
- UnsettableComboBox.cs
- UriWriter.cs
- TableCell.cs
- sqlser.cs
- CodeEventReferenceExpression.cs
- TrustManager.cs
- SQLByte.cs
- ContainerUtilities.cs
- UIPropertyMetadata.cs
- ListViewInsertionMark.cs
- Visual.cs
- DataGridRowEventArgs.cs
- TextEditorSpelling.cs
- LocalizationComments.cs
- BoolExpressionVisitors.cs
- GridSplitterAutomationPeer.cs
- Codec.cs
- UpdatePanel.cs
- BookmarkWorkItem.cs
- GlyphManager.cs
- TaiwanCalendar.cs
- SelectionGlyphBase.cs
- FacetEnabledSchemaElement.cs
- basemetadatamappingvisitor.cs
- DataServiceExpressionVisitor.cs
- FileUpload.cs
- SizeChangedInfo.cs
- TransformGroup.cs
- linebase.cs
- ThreadNeutralSemaphore.cs
- KeySplineConverter.cs
- Nullable.cs
- WebRequestModuleElement.cs
- TerminatorSinks.cs
- PopupControlService.cs
- MissingSatelliteAssemblyException.cs
- SafeViewOfFileHandle.cs
- SerializableAttribute.cs
- UInt16Converter.cs
- ConditionalBranch.cs
- EntityDataSourceSelectedEventArgs.cs