internal void DrawSingleCommand(Graphics g, DrawCommand dc, bool tracked)
{
Rectangle drawRect = dc.DrawRect;
MenuCommand mc = dc.MenuCommand;
// Copy the rectangle used for drawing cell
Rectangle shadowRect = drawRect;
// Expand to right and bottom to cover the area used to draw shadows
shadowRect.Width += _shadowGap;
shadowRect.Height += _shadowGap;
if (!dc.Separator)
{
Rectangle textRect;
// Text rectangle size depends on type of draw command we are drawing
if (dc.Chevron)
{
// Create chevron drawing rectangle
textRect = new Rectangle(drawRect.Left + _lengthGap, drawRect.Top + _boxExpandUpper,
drawRect.Width - _lengthGap * 2, drawRect.Height - (_boxExpandUpper * 2));
}
else
{
// Create text drawing rectangle
textRect = new Rectangle(drawRect.Left + _lengthGap, drawRect.Top + _lengthGap,
drawRect.Width - _lengthGap * 2, drawRect.Height - _lengthGap * 2);
}
if (dc.Enabled)
{
// Draw selection
if (tracked)
{
Rectangle boxRect;
// Create the rectangle for box around the text
if (_direction == Direction.Horizontal)
{
boxRect = new Rectangle(textRect.Left - _boxExpandSides,
textRect.Top - _boxExpandUpper,
textRect.Width + _boxExpandSides * 2,
textRect.Height + _boxExpandUpper);
}
else
{
if (!dc.Chevron)
{
boxRect = new Rectangle(textRect.Left,
textRect.Top - _boxExpandSides,
textRect.Width - _boxExpandSides,
textRect.Height + _boxExpandSides * 2);
}
else
boxRect = textRect;
}
switch(_style)
{
case VisualStyle.IDE:
if (_selected)
{
// Fill the entire inside
g.FillRectangle(Brushes.White, boxRect);
g.FillRectangle(_controlLBrush, boxRect);
Color extraColor = Color.FromArgb(64, 0, 0, 0);
Color darkColor = Color.FromArgb(48, 0, 0, 0);
Color lightColor = Color.FromArgb(0, 0, 0, 0);
int rightLeft = boxRect.Right + 1;
int rightBottom = boxRect.Bottom;
if (_drawUpwards && (_direction == Direction.Horizontal))
{
// Draw the box around the selection area
using(Pen dark = new Pen(ControlPaint.Dark(_selectedBackColor)))
g.DrawRectangle(dark, boxRect);
if (dc.SubMenu)
{
// Right shadow
int rightTop = boxRect.Top;
int leftLeft = boxRect.Left + _shadowGap;
// Bottom shadow
int top = boxRect.Bottom + 1;
int left = boxRect.Left + _shadowGap;
int width = boxRect.Width + 1;
int height = _shadowGap;
Brush rightShadow;
Brush bottomLeftShadow;
Brush bottomShadow;
Brush bottomRightShadow;
// Decide if we need to use an alpha brush
if (_supportsLayered)
{
// Create brushes
rightShadow = new LinearGradientBrush(new Point(rightLeft, 9999),
new Point(rightLeft + _shadowGap, 9999),
darkColor, lightColor);
bottomLeftShadow = new LinearGradientBrush(new Point(left + _shadowGap, top - _shadowGap),
new Point(left, top + height),
extraColor, lightColor);
bottomRightShadow = new LinearGradientBrush(new Point(left + width - _shadowGap - 2, top - _shadowGap - 2),
new Point(left + width, top + height),
extraColor, lightColor);
bottomShadow = new LinearGradientBrush(new Point(9999, top),
new Point(9999, top + height),
darkColor, lightColor);
}
else
{
rightShadow = new SolidBrush(SystemColors.ControlDark);
bottomLeftShadow = rightShadow;
bottomShadow = rightShadow;
bottomRightShadow = rightShadow;
}
// Draw each part of the shadow area
g.FillRectangle(rightShadow, new Rectangle(rightLeft, rightTop, _shadowGap, rightBottom - rightTop + 1));
g.FillRectangle(bottomLeftShadow, left, top, _shadowGap, height);
g.FillRectangle(bottomRightShadow, left + width - _shadowGap, top, _shadowGap, height);
g.FillRectangle(bottomShadow, left + _shadowGap, top, width - _shadowGap * 2, height);
// Dispose of brush objects
if (_supportsLayered)
{
rightShadow.Dispose();
bottomLeftShadow.Dispose();
bottomShadow.Dispose();
bottomRightShadow.Dispose();
}
else
rightShadow.Dispose();
}
}
else
{
// Draw the box around the selection area
using(Pen dark = new Pen(ControlPaint.Dark(_selectedBackColor)))
g.DrawRectangle(dark, boxRect);
if (dc.SubMenu)
{
if (_direction == Direction.Horizontal)
{
// Remove the bottom line of the selection area
g.DrawLine(Pens.White, boxRect.Left, boxRect.Bottom, boxRect.Right, boxRect.Bottom);
g.DrawLine(_controlLPen, boxRect.Left, boxRect.Bottom, boxRect.Right, boxRect.Bottom);
int rightTop = boxRect.Top + _shadowYOffset;
Brush shadowBrush;
// Decide if we need to use an alpha brush
if (_supportsLayered && (_style == VisualStyle.IDE))
{
using(LinearGradientBrush topBrush = new LinearGradientBrush(new Point(rightLeft - _shadowGap, rightTop + _shadowGap),
new Point(rightLeft + _shadowGap, rightTop),
extraColor, lightColor))
{
g.FillRectangle(topBrush, new Rectangle(rightLeft, rightTop, _shadowGap, _shadowGap));
rightTop += _shadowGap;
}
shadowBrush = new LinearGradientBrush(new Point(rightLeft, 9999),
new Point(rightLeft + _shadowGap, 9999),
darkColor, lightColor);
}
else
shadowBrush = new SolidBrush(SystemColors.ControlDark);
g.FillRectangle(shadowBrush, new Rectangle(rightLeft, rightTop, _shadowGap, rightBottom - rightTop));
shadowBrush.Dispose();
}
else
{
// Remove the right line of the selection area
g.DrawLine(Pens.White, boxRect.Right, boxRect.Top, boxRect.Right, boxRect.Bottom);
g.DrawLine(_controlLPen, boxRect.Right, boxRect.Top, boxRect.Right, boxRect.Bottom);
int leftLeft = boxRect.Left + _shadowYOffset;
Brush shadowBrush;
// Decide if we need to use an alpha brush
if (_supportsLayered && (_style == VisualStyle.IDE))
{
using(LinearGradientBrush topBrush = new LinearGradientBrush(new Point(leftLeft + _shadowGap, rightBottom + 1 - _shadowGap),
new Point(leftLeft, rightBottom + 1 + _shadowGap),
extraColor, lightColor))
{
g.FillRectangle(topBrush, new Rectangle(leftLeft, rightBottom + 1, _shadowGap, _shadowGap));
leftLeft += _shadowGap;
}
shadowBrush = new LinearGradientBrush(new Point(9999, rightBottom + 1),
new Point(9999, rightBottom + 1 + _shadowGap),
darkColor, lightColor);
}
else
shadowBrush = new SolidBrush(SystemColors.ControlDark);
g.FillRectangle(shadowBrush, new Rectangle(leftLeft, rightBottom + 1, rightBottom - leftLeft - _shadowGap, _shadowGap));
shadowBrush.Dispose();
}
}
}
}
else
{
using (Pen selectPen = new Pen(_highlightBackDark))
{
// Draw the selection area in white so can alpha draw over the top
g.FillRectangle(Brushes.White, boxRect);
using (SolidBrush selectBrush = new SolidBrush(_highlightBackLight))
{
// Draw the selection area
g.FillRectangle(selectBrush, boxRect);
// Draw a border around the selection area
g.DrawRectangle(selectPen, boxRect);
}
}
}
break;
case VisualStyle.Plain:
if (_plainAsBlock)
{
using (SolidBrush selectBrush = new SolidBrush(_highlightBackDark))
g.FillRectangle(selectBrush, drawRect);
}
else
{
if (_selected)
{
using(Pen lighlight = new Pen(ControlPaint.LightLight(this.BackColor)),
dark = new Pen(ControlPaint.DarkDark(this.BackColor)))
{
g.DrawLine(dark, boxRect.Left, boxRect.Bottom, boxRect.Left, boxRect.Top);
g.DrawLine(dark, boxRect.Left, boxRect.Top, boxRect.Right, boxRect.Top);
g.DrawLine(lighlight, boxRect.Right, boxRect.Top, boxRect.Right, boxRect.Bottom);
g.DrawLine(lighlight, boxRect.Right, boxRect.Bottom, boxRect.Left, boxRect.Bottom);
}
}
else
{
using(Pen lighlight = new Pen(ControlPaint.LightLight(this.BackColor)),
dark = new Pen(ControlPaint.DarkDark(this.BackColor)))
{
g.DrawLine(lighlight, boxRect.Left, boxRect.Bottom, boxRect.Left, boxRect.Top);
g.DrawLine(lighlight, boxRect.Left, boxRect.Top, boxRect.Right, boxRect.Top);
g.DrawLine(dark, boxRect.Right, boxRect.Top, boxRect.Right, boxRect.Bottom);
g.DrawLine(dark, boxRect.Right, boxRect.Bottom, boxRect.Left, boxRect.Bottom);
}
}
}
break;
}
}
}
if (dc.Chevron)
{
// Draw the chevron image in the centre of the text area
int yPos = drawRect.Top;
int xPos = drawRect.X + ((drawRect.Width - _chevronLength) / 2);
// When selected...
if (_selected)
{
// ...offset down and to the right
xPos += 1;
yPos += 1;
}
g.DrawImage(_menuImages.Images[_chevronIndex], xPos, yPos);
}
else
{
// Left align the text drawing on a single line centered vertically
// and process the & character to be shown as an underscore on next character
StringFormat format = new StringFormat();
format.FormatFlags = StringFormatFlags.NoClip | StringFormatFlags.NoWrap;
format.Alignment = StringAlignment.Center;
format.LineAlignment = StringAlignment.Center;
format.HotkeyPrefix = HotkeyPrefix.Show;
if (_direction == Direction.Vertical)
format.FormatFlags |= StringFormatFlags.DirectionVertical;
if (dc.Enabled && this.Enabled)
{
if (tracked && (_style == VisualStyle.Plain) && _plainAsBlock)
{
// Is the item selected as well as tracked?
if (_selected)
{
// Offset to show it is selected
textRect.X += 2;
textRect.Y += 2;
}
using (SolidBrush textBrush = new SolidBrush(_plainSelectedTextColor))
g.DrawString(mc.Text, this.Font, textBrush, textRect, format);
}
else
{
if (_selected && tracked)
{
using (SolidBrush textBrush = new SolidBrush(_selectedTextColor))
g.DrawString(mc.Text, this.Font, textBrush, textRect, format);
}
else
{
if (tracked)
{
using (SolidBrush textBrush = new SolidBrush(_highlightTextColor))
g.DrawString(mc.Text, this.Font, textBrush, textRect, format);
}
else
{
using (SolidBrush textBrush = new SolidBrush(_textColor))
g.DrawString(mc.Text, this.Font, textBrush, textRect, format);
}
}
}
}
else
{
// Helper values used when drawing grayed text in plain style
Rectangle rectDownRight = textRect;
rectDownRight.Offset(1,1);
// Draw the text offset down and right
g.DrawString(mc.Text, this.Font, Brushes.White, rectDownRight, format);
// Draw then text offset up and left
using (SolidBrush grayBrush = new SolidBrush(SystemColors.GrayText))
g.DrawString(mc.Text, this.Font, grayBrush, textRect, format);
}
}
}
}
internal void DrawSingleCommand(Graphics g, DrawCommand dc, bool hotCommand)
{
Rectangle drawRect = dc.DrawRect;
MenuCommand mc = dc.MenuCommand;
// Remember some often used values
int textGapLeft = _position[(int)_style, (int)PI.TextGapLeft];
int imageGapLeft = _position[(int)_style, (int)PI.ImageGapLeft];
int imageGapRight = _position[(int)_style, (int)PI.ImageGapRight];
int imageLeft = drawRect.Left + imageGapLeft;
// Calculate some common values
int imageColWidth = imageGapLeft + _imageWidth + imageGapRight;
int subMenuWidth = _position[(int)_style, (int)PI.SubMenuGapLeft] +
_position[(int)_style, (int)PI.SubMenuWidth] +
_position[(int)_style, (int)PI.SubMenuGapRight];
int subMenuX = drawRect.Right -
_position[(int)_style, (int)PI.SubMenuGapRight] -
_position[(int)_style, (int)PI.SubMenuWidth];
// Text drawing rectangle needs to know the right most position for drawing
// to stop. This is the width of the window minus the relevant values
int shortCutX = subMenuX -
_position[(int)_style, (int)PI.SubMenuGapLeft] -
_position[(int)_style, (int)PI.TextGapRight];
// Is this item an expansion command?
if (dc.Expansion)
{
Rectangle box = drawRect;
// In IDE style the box is next to the image column
if (_style == VisualStyle.IDE)
{
// Reduce the box to take into account the column
box.X += imageColWidth;
box.Width -= imageColWidth;
}
// Find centre for drawing the image
int xPos = box.Left + ((box.Width - _imageHeight) / 2);
int yPos = box.Top + ((box.Height - _imageHeight) / 2);
// Should the item look selected
if (hotCommand)
{
switch(_style)
{
case VisualStyle.IDE:
Rectangle selectArea = new Rectangle(drawRect.Left + 1, drawRect.Top,
drawRect.Width - 3, drawRect.Height - 1);
using (Pen selectPen = new Pen(_highlightColorDark))
{
// Draw the selection area white, because we are going to use an alpha brush
using (SolidBrush whiteBrush = new SolidBrush(Color.White))
g.FillRectangle(whiteBrush, selectArea);
using (SolidBrush selectBrush = new SolidBrush(_highlightColorLight))
{
// Draw the selection area
g.FillRectangle(selectBrush, selectArea);
// Draw a border around the selection area
g.DrawRectangle(selectPen, selectArea);
}
}
break;
case VisualStyle.Plain:
// Shrink the box to provide a small border
box.Inflate(-2, -2);
using (Pen lightPen = new Pen(ControlPaint.LightLight(_backColor)),
darkPen = new Pen(ControlPaint.DarkDark(_backColor)))
{
g.DrawLine(lightPen, box.Right, box.Top, box.Left, box.Top);
g.DrawLine(lightPen, box.Left, box.Top, box.Left, box.Bottom);
g.DrawLine(darkPen, box.Left, box.Bottom, box.Right, box.Bottom);
g.DrawLine(darkPen, box.Right, box.Bottom, box.Right, box.Top);
}
break;
}
}
else
{
switch(_style)
{
case VisualStyle.IDE:
// Fill the entire drawing area with white
g.FillRectangle(_controlLLBrush, new Rectangle(drawRect.Left + 1, drawRect.Top,
drawRect.Width - 1, drawRect.Height));
// Draw the image column background
g.FillRectangle(Brushes.White, new Rectangle(drawRect.Left, drawRect.Top,
imageColWidth, drawRect.Height));
g.FillRectangle(_controlLBrush, new Rectangle(drawRect.Left, drawRect.Top,
imageColWidth, drawRect.Height));
break;
case VisualStyle.Plain:
using(SolidBrush drawBrush = new SolidBrush(_backColor))
g.FillRectangle(drawBrush, new Rectangle(drawRect.Left, drawRect.Top,
drawRect.Width, drawRect.Height));
break;
}
}
// Always draw the expansion bitmap
g.DrawImage(_menuImages.Images[(int)ImageIndex.Expansion], xPos, yPos);
}
else
{
// Is this item a separator?
if (dc.Separator)
{
if (dc.VerticalSeparator)
{
switch(_style)
{
case VisualStyle.IDE:
// Draw the separator as a single line
using (Pen separatorPen = new Pen(ControlPaint.Dark(_backColor)))
g.DrawLine(separatorPen, drawRect.Left, drawRect.Top, drawRect.Left, drawRect.Bottom);
break;
case VisualStyle.Plain:
ButtonBorderStyle bsInset = ButtonBorderStyle.Inset;
ButtonBorderStyle bsNone = ButtonBorderStyle.Inset;
Rectangle sepRect = new Rectangle(drawRect.Left + 1, drawRect.Top, 2, drawRect.Height);
// Draw the separator as two lines using Inset style
ControlPaint.DrawBorder(g, sepRect,
_backColor, 1, bsInset, _backColor, 0, bsNone,
_backColor, 1, bsInset, _backColor, 0, bsNone);
break;
}
}
else
{
switch(_style)
{
case VisualStyle.IDE:
// Draw the image column background
Rectangle imageCol = new Rectangle(drawRect.Left, drawRect.Top, imageColWidth, drawRect.Height);
g.FillRectangle(Brushes.White, imageCol);
g.FillRectangle(_controlLBrush, imageCol);
// Draw a separator
using (Pen separatorPen = new Pen(Color.FromArgb(75, _textColor)))
{
// Draw the separator as a single line
g.DrawLine(separatorPen,
drawRect.Left + imageColWidth + textGapLeft, drawRect.Top + 2,
drawRect.Right,
drawRect.Top + 2);
}
break;
case VisualStyle.Plain:
if (dc.Infrequent && _highlightInfrequent)
{
// Change background to be a lighter shade
using(Brush drawBrush = new SolidBrush(ControlPaint.Light(_backColor)))
g.FillRectangle(drawBrush, drawRect);
}
ButtonBorderStyle bsInset = ButtonBorderStyle.Inset;
ButtonBorderStyle bsNone = ButtonBorderStyle.Inset;
Rectangle sepRect = new Rectangle(drawRect.Left + 2, drawRect.Top + 2, drawRect.Width - 4, 2);
// Draw the separator as two lines using Inset style
ControlPaint.DrawBorder(g, sepRect,
_backColor, 0, bsNone, _backColor, 1, bsInset,
_backColor, 0, bsNone, _backColor, 1, bsInset);
break;
}
}
}
else
{
int leftPos = drawRect.Left + imageColWidth + textGapLeft;
// Should the command be drawn selected?
if (hotCommand)
{
switch(_style)
{
case VisualStyle.IDE:
Rectangle selectArea = new Rectangle(drawRect.Left + 1, drawRect.Top, drawRect.Width - 3, drawRect.Height - 1);
using (Pen selectPen = new Pen(_highlightColorDark))
{
// Draw the selection area white, because we are going to use an alpha brush
using (SolidBrush whiteBrush = new SolidBrush(Color.White))
g.FillRectangle(whiteBrush, selectArea);
using (SolidBrush selectBrush = new SolidBrush(_highlightColorLight))
{
// Draw the selection area
g.FillRectangle(selectBrush, selectArea);
// Draw a border around the selection area
g.DrawRectangle(selectPen, selectArea);
}
}
break;
case VisualStyle.Plain:
using (SolidBrush selectBrush = new SolidBrush(_highlightColorDark))
g.FillRectangle(selectBrush, drawRect);
break;
}
}
else
{
switch(_style)
{
case VisualStyle.IDE:
// Fill the entire drawing area with ControlLightLight
g.FillRectangle(_controlLLBrush, new Rectangle(drawRect.Left + 1, drawRect.Top, drawRect.Width - 1, drawRect.Height));
if (dc.Infrequent && _highlightInfrequent)
{
// Draw the text area in a darker shade
g.FillRectangle(Brushes.White, new Rectangle(leftPos, drawRect.Top, drawRect.Right - leftPos - textGapLeft, drawRect.Height));
g.FillRectangle(_controlEBrush, new Rectangle(leftPos, drawRect.Top, drawRect.Right - leftPos - textGapLeft, drawRect.Height));
}
Rectangle imageCol = new Rectangle(drawRect.Left, drawRect.Top,imageColWidth, drawRect.Height);
// Draw the image column background
g.FillRectangle(Brushes.White, imageCol);
g.FillRectangle(_controlLBrush, imageCol);
break;
case VisualStyle.Plain:
if (dc.Infrequent && _highlightInfrequent)
{
using(Brush drawBrush = new SolidBrush(ControlPaint.Light(_backColor)))
g.FillRectangle(drawBrush, new Rectangle(drawRect.Left, drawRect.Top, drawRect.Width, drawRect.Height));
}
else
{
using(Brush drawBrush = new SolidBrush(_backColor))
g.FillRectangle(drawBrush, new Rectangle(drawRect.Left, drawRect.Top, drawRect.Width, drawRect.Height));
}
if (dc.TopBorder && _highlightInfrequent)
using(Pen drawPen = new Pen(ControlPaint.Dark(_backColor)))
g.DrawLine(drawPen, drawRect.Left, drawRect.Top, drawRect.Right, drawRect.Top);
if (dc.BottomBorder && _highlightInfrequent)
using(Pen drawPen = new Pen(ControlPaint.LightLight(_backColor)))
g.DrawLine(drawPen, drawRect.Left, drawRect.Bottom - 1, drawRect.Right, drawRect.Bottom - 1);
break;
}
}
// Calculate text drawing rectangle
Rectangle strRect = new Rectangle(leftPos, drawRect.Top, shortCutX - leftPos, drawRect.Height);
// Left align the text drawing on a single line centered vertically
// and process the & character to be shown as an underscore on next character
StringFormat format = new StringFormat();
format.FormatFlags = StringFormatFlags.NoClip | StringFormatFlags.NoWrap;
format.Alignment = StringAlignment.Near;
format.LineAlignment = StringAlignment.Center;
format.HotkeyPrefix = HotkeyPrefix.Show;
SolidBrush textBrush;
// Create brush depending on enabled state
if (mc.Enabled)
{
if (!hotCommand || (_style == VisualStyle.IDE))
textBrush = new SolidBrush(_textColor);
else
textBrush = new SolidBrush(_highlightTextColor);
}
else
textBrush = new SolidBrush(SystemColors.GrayText);
// Helper values used when drawing grayed text in plain style
Rectangle rectDownRight = strRect;
rectDownRight.Offset(1,1);
if (mc.Enabled || (_style == VisualStyle.IDE))
g.DrawString(mc.Text, _textFont, textBrush, strRect, format);
else
{
if (_style == VisualStyle.Plain)
{
// Draw grayed text by drawing white string offset down and right
using (SolidBrush whiteBrush = new SolidBrush(Color.White))
g.DrawString(mc.Text, _textFont, whiteBrush, rectDownRight, format);
}
// And then draw in correct color offset up and left
g.DrawString(mc.Text, _textFont, textBrush, strRect, format);
}
if (mc.Shortcut != Shortcut.None)
{
// Right align the shortcut drawing
format.Alignment = StringAlignment.Far;
if (mc.Enabled || (_style == VisualStyle.IDE))
{
// Draw the shortcut text
g.DrawString(GetShortcutText(mc.Shortcut), _textFont, textBrush, strRect, format);
}
else
{
if (_style == VisualStyle.Plain)
{
// Draw grayed text by drawing white string offset down and right
using (SolidBrush whiteBrush = new SolidBrush(Color.White))
g.DrawString(GetShortcutText(mc.Shortcut), _textFont, whiteBrush, rectDownRight, format);
}
// And then draw in corret color offset up and left
g.DrawString(GetShortcutText(mc.Shortcut), _textFont, textBrush, strRect, format);
}
}
// The image offset from top of cell is half the space left after
// subtracting the height of the image from the cell height
int imageTop = drawRect.Top + (drawRect.Height - _imageHeight) / 2;
Image image = null;
// Should a check mark be drawn?
if (mc.Checked)
{
switch(_style)
{
case VisualStyle.IDE:
Pen boxPen;
Brush boxBrush;
if (mc.Enabled)
{
boxPen = new Pen(_highlightColorDark);
boxBrush = new SolidBrush(_highlightColorLightLight);
}
else
{
boxPen = new Pen(SystemColors.GrayText);
boxBrush = new SolidBrush(Color.FromArgb(20, SystemColors.GrayText));
}
Rectangle boxRect = new Rectangle(imageLeft - 1, imageTop - 1, _imageHeight + 2, _imageWidth + 2);
// Fill the checkbox area very slightly
g.FillRectangle(boxBrush, boxRect);
// Draw the box around the checkmark area
g.DrawRectangle(boxPen, boxRect);
boxPen.Dispose();
boxBrush.Dispose();
break;
case VisualStyle.Plain:
break;
}
// Grab either tick or radio button image
if (mc.RadioCheck)
{
if (hotCommand && (_style == VisualStyle.Plain))
image = _menuImages.Images[(int)ImageIndex.RadioSelected];
else
image = _menuImages.Images[(int)ImageIndex.Radio];
}
else
{
if (hotCommand && (_style == VisualStyle.Plain))
image = _menuImages.Images[(int)ImageIndex.CheckSelected];
else
image = _menuImages.Images[(int)ImageIndex.Check];
}
}
else
{
try
{
// Always use the Image property in preference to the ImageList
if (mc.Image != null)
image = mc.Image;
else
{
if ((mc.ImageList != null) && (mc.ImageIndex >= 0))
image = mc.ImageList.Images[mc.ImageIndex];
}
}
catch(Exception)
{
// User supplied ImageList/ImageIndex are invalid, use an error image instead
image = _menuImages.Images[(int)ImageIndex.ImageError];
}
}
// Is there an image to be drawn?
if (image != null)
{
if (mc.Enabled)
{
if ((hotCommand) && (!mc.Checked) && (_style == VisualStyle.IDE))
{
// Draw a gray icon offset down and right
Bitmap shadowImage = new Bitmap((Bitmap) image);
Color shadowColor = Color.FromArgb(154, 156, 146);
Color transparent = Color.FromArgb(0, 0, 0, 0);
for(int pixelX = 0; pixelX < image.Width; pixelX++)
{
for(int pixelY = 0; pixelY < image.Height; pixelY++)
{
if (shadowImage.GetPixel(pixelX, pixelY) != transparent)
shadowImage.SetPixel(pixelX, pixelY, shadowColor);
}
}
g.DrawImage(shadowImage, imageLeft + 1, imageTop + 1);
// Draw an enabled icon offset up and left
g.DrawImage(image, imageLeft - 1, imageTop - 1);
}
else
{
// Draw an faded enabled icon
// A new bitmap so we don't change the actual image
Bitmap fadedImage = new Bitmap(image);
Color transparent = Color.FromArgb(0, 0, 0, 0);
for(int pixelX = 0; pixelX < image.Width; pixelX++)
{
for(int pixelY = 0; pixelY < image.Height; pixelY++)
{
Color pixelColor = fadedImage.GetPixel(pixelX, pixelY);
if (pixelColor != transparent)
{
Color newPixelColor = Color.FromArgb((pixelColor.R + 76) - (((pixelColor.R + 32) / 64) * 19),
(pixelColor.G + 76) - (((pixelColor.G + 32) / 64) * 19),
(pixelColor.B + 76) - (((pixelColor.B + 32) / 64) * 19));
fadedImage.SetPixel(pixelX, pixelY, newPixelColor);
}
}
}
g.DrawImage(fadedImage, imageLeft, imageTop);
// Draw an enabled icon
//g.DrawImage(image, imageLeft, imageTop);
}
}
else
{
// Draw a image disabled
ControlPaint.DrawImageDisabled(g, image, imageLeft, imageTop, SystemColors.HighlightText);
}
}
// Does the menu have a submenu defined?
if (dc.SubMenu)
{
// Is the item enabled?
if (mc.Enabled)
{
int subMenuIndex = (int)ImageIndex.SubMenu;
if (hotCommand && (_style == VisualStyle.Plain))
subMenuIndex = (int)ImageIndex.SubMenuSelected;
// Draw the submenu arrow
g.DrawImage(_menuImages.Images[subMenuIndex], subMenuX, imageTop);
}
else
{
// Draw a image disabled
ControlPaint.DrawImageDisabled(g, _menuImages.Images[(int)ImageIndex.SubMenu],
subMenuX, imageTop, _highlightTextColor);
}
}
}
}
}
internal void OperateSubMenu(DrawCommand dc, bool selectFirst, bool trackRemove)
{
if (this.IsDisposed)
return;
if (dc == null)
return;
Rectangle drawRect = dc.DrawRect;
// Find screen positions for popup menu
Point screenPos;
if (_style == VisualStyle.IDE)
{
if (_direction == Direction.Horizontal)
screenPos = PointToScreen(new Point(dc.DrawRect.Left + 1, drawRect.Bottom - _lengthGap - 2));
else
screenPos = PointToScreen(new Point(dc.DrawRect.Right - _breadthGap, drawRect.Top + _boxExpandSides - 1));
}
else
{
if (_direction == Direction.Horizontal)
screenPos = PointToScreen(new Point(dc.DrawRect.Left + 1, drawRect.Bottom));
else
screenPos = PointToScreen(new Point(dc.DrawRect.Right, drawRect.Top));
}
Point aboveScreenPos;
if (_style == VisualStyle.IDE)
{
if (_direction == Direction.Horizontal)
aboveScreenPos = PointToScreen(new Point(dc.DrawRect.Left + 1, drawRect.Top + _breadthGap + _lengthGap - 1));
else
aboveScreenPos = PointToScreen(new Point(dc.DrawRect.Right - _breadthGap, drawRect.Bottom + _lengthGap + 1));
}
else
{
if (_direction == Direction.Horizontal)
aboveScreenPos = PointToScreen(new Point(dc.DrawRect.Left + 1, drawRect.Top));
else
aboveScreenPos = PointToScreen(new Point(dc.DrawRect.Right, drawRect.Bottom));
}
int borderGap;
// Calculate the missing gap in the PopupMenu border
if (_direction == Direction.Horizontal)
borderGap = dc.DrawRect.Width - _subMenuBorderAdjust;
else
borderGap = dc.DrawRect.Height - _subMenuBorderAdjust;
_popupMenu = new PopupMenu();
if (_popupMenu == null)
return;
// Define the correct visual style based on ours
_popupMenu.Style = this.Style;
// Key direction when keys cause dismissal
int returnDir = 0;
// Command selected by the PopupMenu
MenuCommand returnCommand = null;
// Should the PopupMenu tell the collection to remember expansion state
_popupMenu.RememberExpansion = _rememberExpansion;
// Propogate our highlight setting
_popupMenu.HighlightInfrequent = _highlightInfrequent;
// Might need to define custom colors
if (!_defaultSelectedBackColor)
_popupMenu.BackColor = _selectedBackColor;
if (!_defaultSelectedTextColor)
_popupMenu.TextColor = _selectedTextColor;
if (!_defaultHighlightTextColor)
_popupMenu.HighlightTextColor = _highlightTextColor;
if (!_defaultHighlightBackColor)
_popupMenu.HighlightColor = _highlightBackColor;
if (!_defaultFont)
_popupMenu.Font = base.Font;
// Pass on the animation values
_popupMenu.Animate = _animate;
_popupMenu.AnimateStyle = _animateStyle;
_popupMenu.AnimateTime = _animateTime;
if (dc.Chevron)
{
MenuCommandCollection mcc = new MenuCommandCollection();
bool addCommands = false;
if (_menuCommands != null)
{
// Generate a collection of menu commands for those not visible
foreach(MenuCommand command in _menuCommands)
{
if (!addCommands && (command == _chevronStartCommand))
addCommands = true;
if (addCommands)
mcc.Add(command);
}
}
// Track the popup using provided menu item collection
returnCommand = _popupMenu.TrackPopup(screenPos,
aboveScreenPos,
_direction,
mcc,
borderGap,
selectFirst,
this,
_animateFirst,
ref returnDir);
}
else
{
// Generate event so that caller has chance to modify MenuCommand contents
dc.MenuCommand.OnPopupStart();
// Honour the collections request for showing infrequent items
_popupMenu.ShowInfrequent = dc.MenuCommand.MenuCommands.ShowInfrequent;
// Track the popup using provided menu item collection
returnCommand = _popupMenu.TrackPopup(screenPos,
aboveScreenPos,
_direction,
dc.MenuCommand.MenuCommands,
borderGap,
selectFirst,
this,
_animateFirst,
ref returnDir);
}
// No more animation till simulation ends
_animateFirst = false;
// If we are supposed to expand all items at the same time
if (_expandAllTogether)
{
// Is anything we have shown now in the expanded state
if (AnythingExpanded(_menuCommands))
{
// Set everything to expanded
SetAllCommandsExpansion(_menuCommands, true);
}
}
// Was arrow key not used to dismiss the submenu?
if (returnDir == 0)
{
// The submenu may have eaten the mouse leave event
_mouseOver = false;
// Only if the submenu was dismissed at the request of the submenu
// should the selection mode be cancelled, otherwise keep selection mode
if (!_dismissTransfer)
{
// This item is no longer selected
Deselect();
_drawUpwards = false;
if (!this.IsDisposed)
{
// Should we stop tracking this item
if (trackRemove)
{
// Unselect the current item
_trackItem = SwitchTrackingItem(_trackItem, -1);
}
else
{
if (_trackItem != -1)
{
// Repaint the item
DrawCommand(_trackItem, true);
}
}
}
}
else
{
// Do not change _selected status
_dismissTransfer = false;
}
}
if (!dc.Chevron)
{
// Generate event so that caller has chance to modify MenuCommand contents
dc.MenuCommand.OnPopupEnd();
}
// Spin the message loop so the messages dealing with destroying
// the PopupMenu window are processed and cause it to disappear from
// view before events are generated
Application.DoEvents();
// Remove unwanted object
_popupMenu = null;
// Was arrow key used to dismiss the submenu?
if (returnDir != 0)
{
if (returnDir < 0)
{
// Shift selection left one
ProcessMoveLeft(true);
}
else
{
// Shift selection right one
ProcessMoveRight(true);
}
// A WM_MOUSEMOVE is generated when we open up the new submenu for
// display, ignore this as it causes the selection to move
_ignoreMouseMove = true;
}
else
{
// Was a MenuCommand returned?
if (returnCommand != null)
{
// Remove
// Are we simulating having the focus?
if (_manualFocus)
{
// Always return focus to original when a selection is made
SimulateReturnFocus();
}
// Pulse the selected event for the command
returnCommand.OnClick(EventArgs.Empty);
}
}
}
protected Size GenerateDrawPositions()
{
// Create a collection of drawing objects
_drawCommands = new ArrayList();
// Calculate the minimum cell width and height
int cellMinHeight = _position[(int)_style, (int)PI.ImageGapTop] +
_imageHeight +
_position[(int)_style, (int)PI.ImageGapBottom];
int cellMinWidth = _position[(int)_style, (int)PI.ImageGapLeft] +
_imageWidth +
_position[(int)_style, (int)PI.ImageGapRight] +
_position[(int)_style, (int)PI.TextGapLeft] +
_position[(int)_style, (int)PI.TextGapRight] +
_position[(int)_style, (int)PI.SubMenuGapLeft] +
_position[(int)_style, (int)PI.SubMenuWidth] +
_position[(int)_style, (int)PI.SubMenuGapRight];
// Find cell height needed to draw text
int textHeight = _textFont.Height;
// If height needs to be more to handle image then use image height
if (textHeight < cellMinHeight)
textHeight = cellMinHeight;
// Make sure no column in the menu is taller than the screen
int screenHeight = SystemInformation.WorkingArea.Height;
// Define the starting positions for calculating cells
int xStart = _position[(int)_style, (int)PI.BorderLeft];
int yStart =_position[(int)_style, (int)PI.BorderTop];
int yPosition = yStart;
// Largest cell for column defaults to minimum cell width
int xColumnMaxWidth = cellMinWidth;
int xPreviousColumnWidths = 0;
int xMaximumColumnHeight = 0;
// Track the row/col of each cell
int row = 0;
int col = 0;
// Are there any infrequent items
bool infrequent = false;
bool previousInfrequent = false;
// Get hold of the DC for the desktop
IntPtr hDC = User32.GetDC(IntPtr.Zero);
// Contains the collection of items in the current column
ArrayList columnItems = new ArrayList();
using(Graphics g = Graphics.FromHdc(hDC))
{
// Handle any extra text drawing
if (_menuCommands.ExtraText.Length > 0)
{
// Calculate the column width needed to show this text
SizeF dimension = g.MeasureString(_menuCommands.ExtraText, _menuCommands.ExtraFont);
// Always add 1 to ensure that rounding is up and not down
int extraHeight = (int)dimension.Height + 1;
// Find the total required as the text requirement plus style specific spacers
_extraSize = extraHeight +
_position[(int)_style, (int)PI.ExtraRightGap] +
_position[(int)_style, (int)PI.ExtraWidthGap] * 2;
// Push first column of items across from the extra text
xStart += _extraSize;
// Add this extra width to the total width of the window
xPreviousColumnWidths = _extraSize;
}
foreach(MenuCommand command in _menuCommands)
{
// Give the command a chance to update its state
command.OnUpdate(EventArgs.Empty);
// Ignore items that are marked as hidden
if (!command.Visible)
continue;
// If this command has menu items (and so it a submenu item) then check
// if any of the submenu items are visible. If none are visible then there
// is no point in showing this submenu item
if ((command.MenuCommands.Count > 0) && (!command.MenuCommands.VisibleItems()))
continue;
// Ignore infrequent items unless flag set to show them
if (command.Infrequent && !_showInfrequent)
{
infrequent = true;
continue;
}
int cellWidth = 0;
int cellHeight = 0;
// Shift across to the next column?
if (command.Break)
{
// Move row/col tracking to the next column
row = 0;
col++;
// Apply cell width to the current column entries
ApplySizeToColumnList(columnItems, xColumnMaxWidth);
// Move cell position across to start of separator position
xStart += xColumnMaxWidth;
// Get width of the separator area
int xSeparator = _position[(int)_style, (int)PI.SeparatorWidth];
DrawCommand dcSep = new DrawCommand(new Rectangle(xStart, 0, xSeparator, 0), false);
// Add to list of items for drawing
_drawCommands.Add(dcSep);
// Move over the separator
xStart += xSeparator;
// Reset cell position to top of column
yPosition = yStart;
// Accumulate total width of previous columns
xPreviousColumnWidths += xColumnMaxWidth + xSeparator;
// Largest cell for column defaults to minimum cell width
xColumnMaxWidth = cellMinWidth;
}
// Is this a horizontal separator?
if (command.Text == "-")
{
cellWidth = cellMinWidth;
cellHeight = _position[(int)_style, (int)PI.SeparatorHeight];
}
else
{
// Use precalculated height
cellHeight = textHeight;
// Calculate the text width portion of the cell
SizeF dimension = g.MeasureString(command.Text, _textFont);
// Always add 1 to ensure that rounding is up and not down
cellWidth = cellMinWidth + (int)dimension.Width + 1;
// Does the menu command have a shortcut defined?
if (command.Shortcut != Shortcut.None)
{
// Find the width of the shortcut text
dimension = g.MeasureString(GetShortcutText(command.Shortcut), _textFont);
// Add to the width of the cell
cellWidth += _position[(int)_style, (int)PI.ShortcutGap] + (int)dimension.Width + 1;
}
}
// If the new cell expands past the end of the screen...
if ((yPosition + cellHeight) >= screenHeight)
{
// .. then need to insert a column break
// Move row/col tracking to the next column
row = 0;
col++;
// Apply cell width to the current column entries
ApplySizeToColumnList(columnItems, xColumnMaxWidth);
// Move cell position across to start of separator position
xStart += xColumnMaxWidth;
// Get width of the separator area
int xSeparator = _position[(int)_style, (int)PI.SeparatorWidth];
DrawCommand dcSep = new DrawCommand(new Rectangle(xStart, yStart, xSeparator, 0), false);
// Add to list of items for drawing
_drawCommands.Add(dcSep);
// Move over the separator
xStart += xSeparator;
// Reset cell position to top of column
yPosition = yStart;
// Accumulate total width of previous columns
xPreviousColumnWidths += xColumnMaxWidth + xSeparator;
// Largest cell for column defaults to minimum cell width
xColumnMaxWidth = cellMinWidth;
// Show this be drawn in the infrequent colors
dcSep.Infrequent = previousInfrequent;
}
// Create a new position rectangle (the width will be reset later once the
// width of the column has been determined but the other values are correct)
Rectangle cellRect = new Rectangle(xStart, yPosition, cellWidth, cellHeight);
// Create a drawing object
DrawCommand dc = new DrawCommand(command, cellRect, row, col);
// Is the infrequent state different from previous commands?
if (previousInfrequent != command.Infrequent)
{
// If was not infrequent but now is
if (command.Infrequent)
{
// Then draw this infrequent item with a top border
dc.TopBorder = true;
}
else
{
if (_drawCommands.Count > 0)
{
// Find the previous command (excluding separators) and make it as needed a border
for(int index = _drawCommands.Count - 1; index>=0; index--)
{
if (!( _drawCommands[index] as DrawCommand).Separator)
{
(_drawCommands[index] as DrawCommand).BottomBorder = true;
break;
}
}
}
}
}
// Remember the state of previous command only if not a separator
if (!dc.Separator)
previousInfrequent = command.Infrequent;
// Add to list of items for drawing
_drawCommands.Add(dc);
// Add to list of items in this column
columnItems.Add(dc);
// Remember the biggest cell width in this column
if (cellWidth > xColumnMaxWidth)
xColumnMaxWidth = cellWidth;
// Move down to start of next cell in column
yPosition += cellHeight;
// Remember the tallest column in the menu
if (yPosition > xMaximumColumnHeight)
xMaximumColumnHeight = yPosition;
row++;
}
// Check if we need to add an infrequent expansion item
if (infrequent)
{
// Create a minimum size cell
Rectangle cellRect = new Rectangle(xStart, yPosition, cellMinWidth, cellMinHeight);
// Create a draw command to represent the drawing of the expansion item
DrawCommand dc = new DrawCommand(cellRect, true);
// Must be last item
_drawCommands.Add(dc);
// Add to list of items in this column
columnItems.Add(dc);
yPosition += cellMinHeight;
// Remember the tallest column in the menu
if (yPosition > xMaximumColumnHeight)
xMaximumColumnHeight = yPosition;
}
// Apply cell width to the current column entries
ApplySizeToColumnList(columnItems, xColumnMaxWidth);
}
// Must remember to release the HDC resource!
User32.ReleaseDC(IntPtr.Zero, hDC);
// Find width/height of window
int windowWidth = _position[(int)_style, (int)PI.BorderLeft] +
xPreviousColumnWidths +
xColumnMaxWidth +
_position[(int)_style, (int)PI.BorderRight];
int windowHeight = _position[(int)_style, (int)PI.BorderTop] +
xMaximumColumnHeight +
_position[(int)_style, (int)PI.BorderBottom];
// Define the height of the vertical separators
ApplyVerticalSeparators(xMaximumColumnHeight);
// Style specific modification of window size
int xAdd = _position[(int)_style, (int)PI.ShadowHeight];
int yAdd = _position[(int)_style, (int)PI.ShadowWidth];
if (_style == VisualStyle.Plain)
{
xAdd += SystemInformation.Border3DSize.Width * 2;
yAdd += SystemInformation.Border3DSize.Height * 2;
}
return new Size(windowWidth + xAdd, windowHeight + yAdd);
}