2061 lines
64 KiB
C#
2061 lines
64 KiB
C#
using System;
|
|
using System.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Windows.Forms;
|
|
using System.Drawing.Text;
|
|
using DevComponents.DotNetBar.Rendering;
|
|
using DevComponents.DotNetBar.Rendering;
|
|
|
|
namespace DevComponents.DotNetBar
|
|
{
|
|
/// <summary>
|
|
/// Indicates the Balloon tip position.
|
|
/// </summary>
|
|
public enum eTipPosition
|
|
{
|
|
/// <summary>
|
|
/// Tip is on the top.
|
|
/// </summary>
|
|
Top=0,
|
|
/// <summary>
|
|
/// Tip is on the left side.
|
|
/// </summary>
|
|
Left=1,
|
|
/// <summary>
|
|
/// Tip is on the right side.
|
|
/// </summary>
|
|
Right=2,
|
|
/// <summary>
|
|
/// Tip is on the bottom.
|
|
/// </summary>
|
|
Bottom=3
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates the style of the balloon.
|
|
/// </summary>
|
|
public enum eBallonStyle
|
|
{
|
|
Balloon=0,
|
|
Alert=1,
|
|
Office2007Alert
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates type of Alert animation performed when alert is displayed.
|
|
/// </summary>
|
|
public enum eAlertAnimation
|
|
{
|
|
/// <summary>
|
|
/// No animation take place when alert is displayed.
|
|
/// </summary>
|
|
None=0,
|
|
/// <summary>
|
|
/// Alert is animated from bottom to top. (Default)
|
|
/// </summary>
|
|
BottomToTop=1,
|
|
/// <summary>
|
|
/// Alert is animated from top to bottom.
|
|
/// </summary>
|
|
TopToBottom=2,
|
|
/// <summary>
|
|
/// Alert is animated from left to right.
|
|
/// </summary>
|
|
LeftToRight=3,
|
|
/// <summary>
|
|
/// Alert is animated from right to left.
|
|
/// </summary>
|
|
RightToLeft=4
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delegate for custom paint event handler.
|
|
/// </summary>
|
|
public delegate void CustomPaintEventHandler(object sender, CustomPaintEventArgs e);
|
|
|
|
/// <summary>
|
|
/// Summary description for Balloon.
|
|
/// </summary>
|
|
[ToolboxItem(false), System.Runtime.InteropServices.ComVisible(false), Designer("System.Windows.Forms.Design.ParentControlDesigner, System.Design, Version= 2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
|
|
public class Balloon : System.Windows.Forms.Form
|
|
{
|
|
private System.ComponentModel.IContainer components;
|
|
#region Event Definition
|
|
/// <summary>
|
|
/// Occurs when background is redrawn.
|
|
/// </summary>
|
|
public event CustomPaintEventHandler PaintBackground;
|
|
/// <summary>
|
|
/// Occurs when caption image is redrawn.
|
|
/// </summary>
|
|
public event CustomPaintEventHandler PaintCaptionImage;
|
|
/// <summary>
|
|
/// Occurs when caption text is redrawn.
|
|
/// </summary>
|
|
public event CustomPaintEventHandler PaintCaptionText;
|
|
/// <summary>
|
|
/// Occurs when text is redrawn.
|
|
/// </summary>
|
|
public event CustomPaintEventHandler PaintText;
|
|
/// <summary>
|
|
/// Occurs when close button is clicked.
|
|
/// </summary>
|
|
public event EventHandler CloseButtonClick;
|
|
/// <summary>
|
|
/// Occurs when TipPosition property has changed.
|
|
/// </summary>
|
|
public event EventHandler TipPositionChanged;
|
|
#endregion
|
|
|
|
|
|
private int m_TipLength=16;
|
|
private int m_CornerSize=8;
|
|
private int m_TipOffset=32;
|
|
private eTipPosition m_TipPosition=eTipPosition.Top;
|
|
|
|
private Color m_BackColor2=Color.Empty;
|
|
private int m_BackColorGradientAngle=90;
|
|
|
|
private eBackgroundImagePosition m_BackgroundImagePosition=eBackgroundImagePosition.Stretch;
|
|
private int m_BackgroundImageAlpha=255;
|
|
|
|
private Color m_BorderColor=SystemColors.InfoText;
|
|
|
|
private bool m_ShowCloseButton=true;
|
|
private ImageButton m_CloseButton=null;
|
|
|
|
private eBallonStyle m_Style=eBallonStyle.Balloon;
|
|
|
|
private Image m_CloseButtonNormal=null, m_CloseButtonHot=null, m_CloseButtonPressed=null;
|
|
private Image m_CaptionImage=null;
|
|
private Icon m_CaptionIcon=null;
|
|
private Font m_CaptionFont=null;
|
|
private string m_CaptionText="";
|
|
private StringAlignment m_CaptionAlignment=StringAlignment.Near;
|
|
private Color m_CaptionColor=SystemColors.InfoText;
|
|
|
|
private StringAlignment m_TextAlignment=StringAlignment.Near;
|
|
private StringAlignment m_TextLineAlignment=StringAlignment.Center;
|
|
|
|
// Layout rectangles
|
|
private Rectangle m_CaptionImageRectangle=Rectangle.Empty;
|
|
private Rectangle m_CaptionRectangle=Rectangle.Empty;
|
|
private Rectangle m_TextRectangle=Rectangle.Empty;
|
|
|
|
private bool m_AutoClose=true;
|
|
private int m_AutoCloseTimeOut=0;
|
|
private System.Windows.Forms.Timer m_Timer=null;
|
|
|
|
const int IMAGETEXT_SPACING=4;
|
|
const int TEXTCLOSE_SPACING=4;
|
|
const int CAPTIONTEXT_VSPACING=1;
|
|
const int CAPTIONALERT_VSPACING=1;
|
|
|
|
private Color m_BorderColor1=Color.FromArgb(241,239,226);
|
|
private Color m_BorderColor2=Color.White;
|
|
private Color m_BorderColor3=Color.FromArgb(236,233,216);
|
|
private Color m_BorderColor4=Color.FromArgb(172,168,153);
|
|
private Color m_BorderColor5=Color.FromArgb(113,111,100);
|
|
|
|
private eAlertAnimation m_AlertAnimation=eAlertAnimation.BottomToTop;
|
|
private int m_AlertAnimationDuration=200;
|
|
private bool m_AnimationInProgress=false;
|
|
private bool m_AntiAlias = true;
|
|
|
|
public Balloon()
|
|
{
|
|
CreateCloseButton();
|
|
//
|
|
// Required for Windows Form Designer support
|
|
//
|
|
InitializeComponent();
|
|
if(components==null)
|
|
this.components = new System.ComponentModel.Container();
|
|
m_CaptionFont=new Font(this.Font,FontStyle.Bold);
|
|
|
|
this.SetStyle(ControlStyles.UserPaint,true);
|
|
this.SetStyle(ControlStyles.AllPaintingInWmPaint,true);
|
|
//this.SetStyle(ControlStyles.Opaque,true);
|
|
this.SetStyle(ControlStyles.ResizeRedraw,true);
|
|
this.SetStyle(DisplayHelp.DoubleBufferFlag,true);
|
|
this.SetStyle(ControlStyles.ContainerControl,true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clean up any resources being used.
|
|
/// </summary>
|
|
protected override void Dispose( bool disposing )
|
|
{
|
|
DestroyAutoCloseTimer();
|
|
if( disposing )
|
|
{
|
|
if(components != null)
|
|
{
|
|
components.Dispose();
|
|
}
|
|
}
|
|
|
|
if (BarUtilities.DisposeItemImages && !this.DesignMode)
|
|
{
|
|
BarUtilities.DisposeImage(ref m_CaptionIcon);
|
|
BarUtilities.DisposeImage(ref m_CaptionImage);
|
|
BarUtilities.DisposeImage(ref m_CloseButtonHot);
|
|
BarUtilities.DisposeImage(ref m_CloseButtonNormal);
|
|
BarUtilities.DisposeImage(ref m_CloseButtonPressed);
|
|
}
|
|
base.Dispose( disposing );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether anti-alias smoothing is used while painting. Default value is false.
|
|
/// </summary>
|
|
[DefaultValue(true), Browsable(true), Category("Appearance"), Description("Gets or sets whether anti-aliasing is used while painting.")]
|
|
public bool AntiAlias
|
|
{
|
|
get { return m_AntiAlias; }
|
|
set
|
|
{
|
|
m_AntiAlias = value;
|
|
this.Invalidate();
|
|
}
|
|
}
|
|
|
|
#region Windows Form Designer generated code
|
|
/// <summary>
|
|
/// Required method for Designer support - do not modify
|
|
/// the contents of this method with the code editor.
|
|
/// </summary>
|
|
private void InitializeComponent()
|
|
{
|
|
//
|
|
// Balloon
|
|
//
|
|
this.AccessibleRole = System.Windows.Forms.AccessibleRole.HelpBalloon;
|
|
this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
|
|
this.AutoScaleMode = AutoScaleMode.None;
|
|
this.BackColor = System.Drawing.SystemColors.Info; // ColorScheme.GetColor(0xFFFFBD);//
|
|
this.ClientSize = new System.Drawing.Size(192, 80);
|
|
this.ControlBox = false;
|
|
this.ForeColor = System.Drawing.SystemColors.InfoText;
|
|
this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
|
|
this.MaximizeBox = false;
|
|
this.MinimizeBox = false;
|
|
this.Name = "Balloon";
|
|
this.ShowInTaskbar = false;
|
|
this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
|
|
|
|
}
|
|
#endregion
|
|
|
|
protected override void OnClick(EventArgs e)
|
|
{
|
|
if(m_ShowCloseButton && m_CloseButton.Bounds.Contains(this.PointToClient(Control.MousePosition)))
|
|
return;
|
|
base.OnClick(e);
|
|
}
|
|
|
|
protected override void OnPaint(PaintEventArgs e)
|
|
{
|
|
SmoothingMode sm = e.Graphics.SmoothingMode;
|
|
TextRenderingHint th = e.Graphics.TextRenderingHint;
|
|
|
|
if (m_AntiAlias)
|
|
{
|
|
e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
|
|
e.Graphics.TextRenderingHint = DisplayHelp.AntiAliasTextRenderingHint;
|
|
}
|
|
|
|
if(m_Style==eBallonStyle.Balloon)
|
|
PaintBalloon(e.Graphics);
|
|
else
|
|
PaintAlert(e.Graphics);
|
|
|
|
e.Graphics.SmoothingMode = sm;
|
|
e.Graphics.TextRenderingHint = th;
|
|
}
|
|
|
|
private void PaintAlert(Graphics g)
|
|
{
|
|
Rectangle client=this.GetAlertClientRect();
|
|
if(PaintBackground!=null)
|
|
PaintBackground(this,new CustomPaintEventArgs(g,client));
|
|
else
|
|
{
|
|
PaintBackgroundInternal(g);
|
|
if (m_Style == eBallonStyle.Alert)
|
|
{
|
|
// Paint Caption Background
|
|
Rectangle rCap = client;
|
|
rCap.Height = Math.Max(m_CaptionImageRectangle.Bottom, m_CaptionRectangle.Bottom) - rCap.Top;
|
|
rCap.Height += CAPTIONALERT_VSPACING;
|
|
if (rCap.Width > 0 && rCap.Height > 0)
|
|
{
|
|
using (LinearGradientBrush gradient = BarFunctions.CreateLinearGradientBrush(rCap, this.BackColor, m_BackColor2, m_BackColorGradientAngle))
|
|
{
|
|
Blend b = new Blend(4);
|
|
b.Positions = new float[] { 0f, .5f, .5f, 1f };
|
|
b.Factors = new float[] { 0f, 1f, 1f, 0f };
|
|
gradient.Blend = b;
|
|
g.FillRectangle(gradient, rCap);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Draw Border
|
|
Rectangle r=this.DisplayRectangle;
|
|
if (m_Style == eBallonStyle.Office2007Alert)
|
|
{
|
|
DisplayHelp.DrawRectangle(g, m_BorderColor, r);
|
|
}
|
|
else
|
|
{
|
|
r.Width--;
|
|
r.Height--;
|
|
using (Pen pen = new Pen(m_BorderColor1, 1))
|
|
{
|
|
g.DrawLine(pen, r.X, r.Y, r.Right, r.Y);
|
|
g.DrawLine(pen, r.X, r.Y, r.X, r.Bottom);
|
|
g.DrawLine(pen, r.X + 4, r.Bottom - 4, r.Right - 4, r.Bottom - 4);
|
|
g.DrawLine(pen, r.Right - 4, r.Y + 4, r.Right - 4, r.Bottom - 4);
|
|
}
|
|
using (Pen pen = new Pen(m_BorderColor2, 1))
|
|
{
|
|
g.DrawLine(pen, r.X + 1, r.Y + 1, r.Right - 1, r.Y + 1);
|
|
g.DrawLine(pen, r.X + 1, r.Y + 1, r.X + 1, r.Bottom - 1);
|
|
g.DrawLine(pen, r.X + 3, r.Bottom - 3, r.Right - 3, r.Bottom - 3);
|
|
g.DrawLine(pen, r.Right - 3, r.Y + 3, r.Right - 3, r.Bottom - 3);
|
|
}
|
|
using (Pen pen = new Pen(m_BorderColor3, 1))
|
|
{
|
|
g.DrawLine(pen, r.X + 2, r.Y + 2, r.Right - 2, r.Y + 2);
|
|
g.DrawLine(pen, r.X + 2, r.Y + 2, r.X + 2, r.Bottom - 2);
|
|
g.DrawLine(pen, r.X + 2, r.Bottom - 2, r.Right - 2, r.Bottom - 2);
|
|
g.DrawLine(pen, r.Right - 2, r.Y + 2, r.Right - 2, r.Bottom - 2);
|
|
}
|
|
using (Pen pen = new Pen(m_BorderColor4, 1))
|
|
{
|
|
g.DrawLine(pen, r.X + 3, r.Y + 3, r.Right - 3, r.Y + 3);
|
|
g.DrawLine(pen, r.X + 3, r.Y + 3, r.X + 3, r.Bottom - 3);
|
|
g.DrawLine(pen, r.X + 1, r.Bottom - 1, r.Right - 1, r.Bottom - 1);
|
|
g.DrawLine(pen, r.Right - 1, r.Y + 1, r.Right - 1, r.Bottom - 1);
|
|
}
|
|
using (Pen pen = new Pen(m_BorderColor5, 1))
|
|
{
|
|
g.DrawLine(pen, r.X + 4, r.Y + 4, r.Right - 4, r.Y + 4);
|
|
g.DrawLine(pen, r.X + 4, r.Y + 4, r.X + 4, r.Bottom - 4);
|
|
g.DrawLine(pen, r.X, r.Bottom, r.Right, r.Bottom);
|
|
g.DrawLine(pen, r.Right, r.Y, r.Right, r.Bottom);
|
|
}
|
|
}
|
|
|
|
|
|
if(m_CloseButton!=null)
|
|
m_CloseButton.Paint(g);
|
|
|
|
if(PaintCaptionImage!=null)
|
|
PaintCaptionImage(this,new CustomPaintEventArgs(g,m_CaptionImageRectangle));
|
|
else
|
|
{
|
|
CompositeImage image=this.ImageInternal;
|
|
if(image!=null && !m_CaptionImageRectangle.IsEmpty)
|
|
image.DrawImage(g,m_CaptionImageRectangle);
|
|
}
|
|
|
|
if(PaintCaptionText!=null)
|
|
PaintCaptionText(this,new CustomPaintEventArgs(g,m_CaptionRectangle));
|
|
else
|
|
{
|
|
if(m_CaptionText!="" && !m_CaptionRectangle.IsEmpty)
|
|
{
|
|
eTextFormat format = eTextFormat.Default | eTextFormat.WordBreak;
|
|
if (m_CaptionAlignment == StringAlignment.Center)
|
|
format |= eTextFormat.HorizontalCenter;
|
|
else if (m_CaptionAlignment == StringAlignment.Far)
|
|
format |= eTextFormat.Right;
|
|
Font font=m_CaptionFont;
|
|
if(font==null)
|
|
font=this.Font;
|
|
if (_CaptionTextMarkup != null)
|
|
{
|
|
TextMarkup.MarkupDrawContext d = new TextMarkup.MarkupDrawContext(g, font, m_CaptionColor, (this.RightToLeft == RightToLeft.Yes), r, true);
|
|
_CaptionTextMarkup.Arrange(m_CaptionRectangle, d);
|
|
_CaptionTextMarkup.Render(d);
|
|
}
|
|
else
|
|
TextDrawing.DrawString(g, m_CaptionText, font, m_CaptionColor, m_CaptionRectangle, format);
|
|
}
|
|
}
|
|
|
|
if(PaintText!=null)
|
|
PaintText(this,new CustomPaintEventArgs(g,m_TextRectangle));
|
|
else
|
|
{
|
|
if(this.Text!="")
|
|
{
|
|
eTextFormat format = eTextFormat.Default | eTextFormat.WordBreak;
|
|
if (m_TextAlignment == StringAlignment.Center)
|
|
format |= eTextFormat.HorizontalCenter;
|
|
else if (m_TextAlignment == StringAlignment.Far)
|
|
format |= eTextFormat.Right;
|
|
if (m_TextLineAlignment == StringAlignment.Center)
|
|
format |= eTextFormat.VerticalCenter;
|
|
else if (m_TextLineAlignment == StringAlignment.Far)
|
|
format |= eTextFormat.Bottom;
|
|
if (_TextMarkup != null)
|
|
{
|
|
TextMarkup.MarkupDrawContext d = new TextMarkup.MarkupDrawContext(g, this.Font, this.ForeColor,
|
|
(this.RightToLeft == RightToLeft.Yes), r, true);
|
|
_TextMarkup.Arrange(m_TextRectangle, d);
|
|
_TextMarkup.Render(d);
|
|
}
|
|
else
|
|
TextDrawing.DrawString(g, this.Text, this.Font, this.ForeColor, m_TextRectangle, format);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void PaintBalloon(Graphics g)
|
|
{
|
|
Rectangle r = new Rectangle(0, 0, this.Width, this.Height); //this.DisplayRectangle;
|
|
GraphicsPath path=this.GetBalloonPath(r);
|
|
if(PaintBackground!=null)
|
|
PaintBackground(this,new CustomPaintEventArgs(g,r));
|
|
else
|
|
PaintBackgroundInternal(g);
|
|
|
|
using(Pen pen=new Pen(m_BorderColor,1))
|
|
{
|
|
pen.Alignment=PenAlignment.Inset;
|
|
g.DrawPath(pen,path);
|
|
}
|
|
|
|
if(m_CloseButton!=null)
|
|
m_CloseButton.Paint(g);
|
|
|
|
if(PaintCaptionImage!=null)
|
|
PaintCaptionImage(this,new CustomPaintEventArgs(g,m_CaptionImageRectangle));
|
|
else
|
|
{
|
|
CompositeImage image=this.ImageInternal;
|
|
if(image!=null && !m_CaptionImageRectangle.IsEmpty)
|
|
image.DrawImage(g,m_CaptionImageRectangle);
|
|
}
|
|
|
|
if(PaintCaptionText!=null)
|
|
PaintCaptionText(this,new CustomPaintEventArgs(g,m_CaptionRectangle));
|
|
else
|
|
{
|
|
if(m_CaptionText!="" && !m_CaptionRectangle.IsEmpty)
|
|
{
|
|
eTextFormat format = eTextFormat.Default | TextDrawing.TranslateHorizontal(m_CaptionAlignment) | eTextFormat.WordBreak;
|
|
Font font = m_CaptionFont;
|
|
if (font == null)
|
|
font = this.Font;
|
|
|
|
|
|
if (_CaptionTextMarkup != null)
|
|
{
|
|
TextMarkup.MarkupDrawContext d = new TextMarkup.MarkupDrawContext(g, font, m_CaptionColor, (this.RightToLeft == RightToLeft.Yes), r, true);
|
|
_CaptionTextMarkup.Arrange(m_CaptionRectangle, d);
|
|
_CaptionTextMarkup.Render(d);
|
|
}
|
|
else
|
|
TextDrawing.DrawString(g, m_CaptionText, font, m_CaptionColor, m_CaptionRectangle, format);
|
|
}
|
|
}
|
|
|
|
if(PaintText!=null)
|
|
PaintText(this,new CustomPaintEventArgs(g,m_TextRectangle));
|
|
else
|
|
{
|
|
if(this.Text!="")
|
|
{
|
|
eTextFormat format = eTextFormat.Default | TextDrawing.TranslateHorizontal(m_TextAlignment) |
|
|
TextDrawing.TranslateVertical(m_TextLineAlignment) | eTextFormat.WordBreak;
|
|
if (_TextMarkup != null)
|
|
{
|
|
TextMarkup.MarkupDrawContext d = new TextMarkup.MarkupDrawContext(g, this.Font, this.ForeColor,
|
|
(this.RightToLeft == RightToLeft.Yes), r, true);
|
|
_TextMarkup.Arrange(m_TextRectangle, d);
|
|
_TextMarkup.Render(d);
|
|
}
|
|
else
|
|
TextDrawing.DrawString(g, this.Text, this.Font, this.ForeColor, m_TextRectangle, format);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnResize(EventArgs e)
|
|
{
|
|
base.OnResize(e);
|
|
if(!m_AnimationInProgress)
|
|
this.RecalcLayout();
|
|
}
|
|
private int _MinimumBalloonWidth = 180;
|
|
/// <summary>
|
|
/// Gets or sets the minimum balloon width when auto sizing balloon. Default value is 180.
|
|
/// </summary>
|
|
[DefaultValue(180), Category("Appearance"), Description("Indicates minimum balloon width when auto sizing balloon.")]
|
|
public int MinimumBalloonWidth
|
|
{
|
|
get { return _MinimumBalloonWidth; }
|
|
set { _MinimumBalloonWidth = value; }
|
|
}
|
|
|
|
private TextMarkup.BodyElement _TextMarkup = null;
|
|
protected override void OnTextChanged(EventArgs e)
|
|
{
|
|
string text = this.Text;
|
|
|
|
if (_TextMarkup != null)
|
|
{
|
|
_TextMarkup.MouseLeave(this);
|
|
_TextMarkup.HyperLinkClick -= new EventHandler(TextMarkupLinkClicked);
|
|
_TextMarkup = null;
|
|
}
|
|
|
|
if (TextMarkup.MarkupParser.IsMarkup(ref text))
|
|
_TextMarkup = TextMarkup.MarkupParser.Parse(text);
|
|
|
|
if (_TextMarkup != null)
|
|
{
|
|
_TextMarkup.HyperLinkClick += new EventHandler(TextMarkupLinkClicked);
|
|
}
|
|
this.Invalidate();
|
|
base.OnTextChanged(e);
|
|
}
|
|
|
|
private void TextMarkupLinkClicked(object sender, EventArgs e)
|
|
{
|
|
TextMarkup.HyperLink link = sender as TextMarkup.HyperLink;
|
|
if (link != null)
|
|
{
|
|
OnMarkupLinkClick(new MarkupLinkClickEventArgs(link.Name, link.HRef));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Occurs when text markup link is clicked. Markup links can be created using "a" tag, for example:
|
|
/// <a name="MyLink">Markup link</a>
|
|
/// </summary>
|
|
[Description("Occurs when text markup link is clicked. Markup links can be created using <a> tag.")]
|
|
public event MarkupLinkClickEventHandler MarkupLinkClick;
|
|
|
|
protected virtual void OnMarkupLinkClick(MarkupLinkClickEventArgs e)
|
|
{
|
|
if (this.MarkupLinkClick != null)
|
|
MarkupLinkClick(this, e);
|
|
}
|
|
|
|
protected virtual Size ResizeMarkup(Graphics g, int containerWidth)
|
|
{
|
|
if (_TextMarkup != null)
|
|
{
|
|
Rectangle r= new Rectangle(0,0,containerWidth, 1);
|
|
TextMarkup.MarkupDrawContext d = new TextMarkup.MarkupDrawContext(g, this.Font, SystemColors.Control, (this.RightToLeft == RightToLeft.Yes));
|
|
_TextMarkup.Measure(r.Size, d);
|
|
//_TextMarkup.Arrange(r, d);
|
|
return _TextMarkup.Bounds.Size;
|
|
}
|
|
return Size.Empty;
|
|
}
|
|
|
|
protected virtual Size ResizeCaptionMarkup(Graphics g, int containerWidth)
|
|
{
|
|
if (_CaptionTextMarkup != null)
|
|
{
|
|
Rectangle r = new Rectangle(0, 0, containerWidth, 1);
|
|
TextMarkup.MarkupDrawContext d = new TextMarkup.MarkupDrawContext(g, this.Font, SystemColors.Control, (this.RightToLeft == RightToLeft.Yes));
|
|
_CaptionTextMarkup.Measure(r.Size, d);
|
|
//_TextMarkup.Arrange(r, d);
|
|
return _CaptionTextMarkup.Bounds.Size;
|
|
}
|
|
return Size.Empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Auto resize balloon to the content. Balloon width is calculated so image and caption text can fit in single line.
|
|
/// </summary>
|
|
public void AutoResize()
|
|
{
|
|
System.Drawing.Size newSize = new Size(Dpi.Width(_MinimumBalloonWidth), 0);
|
|
|
|
Size strSize=Size.Empty;
|
|
|
|
// Calculates caption text rectangle height
|
|
Font font=m_CaptionFont;
|
|
if(font==null)
|
|
font=this.Font;
|
|
Graphics g=this.CreateGraphics();
|
|
try
|
|
{
|
|
if (_CaptionTextMarkup != null)
|
|
strSize = ResizeCaptionMarkup(g, 800);
|
|
else
|
|
strSize = TextDrawing.MeasureString(g,(m_CaptionText != "" ? m_CaptionText : " "), font);
|
|
|
|
newSize.Width = Math.Max(newSize.Width, strSize.Width);
|
|
if(m_CloseButton!=null)
|
|
newSize.Width+=Dpi.Width(m_CloseButton.Size.Width);
|
|
else
|
|
newSize.Width+=Dpi.Width18;
|
|
newSize.Width+=TEXTCLOSE_SPACING;
|
|
|
|
int imageHeight=0;
|
|
if(m_CaptionIcon!=null)
|
|
{
|
|
newSize.Width+=Dpi.Width(m_CaptionIcon.Width+IMAGETEXT_SPACING);
|
|
imageHeight = Dpi.Height(m_CaptionIcon.Height);
|
|
}
|
|
else if(m_CaptionImage!=null)
|
|
{
|
|
newSize.Width+=Dpi.Width(m_CaptionImage.Width+IMAGETEXT_SPACING);
|
|
imageHeight = Dpi.Height(m_CaptionImage.Height);
|
|
}
|
|
|
|
newSize.Height+=Math.Max(imageHeight,strSize.Height);
|
|
newSize.Height+=IMAGETEXT_SPACING*2;
|
|
|
|
if (_TextMarkup == null)
|
|
strSize = TextDrawing.MeasureString(g, (this.Text != "" ? this.Text : " "), this.Font, newSize.Width,
|
|
eTextFormat.Default | eTextFormat.WordBreak);
|
|
else
|
|
strSize = ResizeMarkup(g, newSize.Width);
|
|
|
|
newSize.Height+=strSize.Height;
|
|
|
|
newSize.Width+=m_CornerSize*2;
|
|
newSize.Height+=m_CornerSize*2;
|
|
|
|
if(m_Style==eBallonStyle.Balloon)
|
|
{
|
|
if(m_TipPosition==eTipPosition.Left || m_TipPosition==eTipPosition.Right)
|
|
newSize.Width+=Dpi.Width(m_TipLength);
|
|
else
|
|
newSize.Height+=Dpi.Height(m_TipLength);
|
|
}
|
|
else
|
|
newSize.Height+=(int)((float)newSize.Height*.3);
|
|
}
|
|
finally
|
|
{
|
|
g.Dispose();
|
|
}
|
|
|
|
this.Size=newSize;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recalculates layout of the balloon.
|
|
/// </summary>
|
|
public void RecalcLayout()
|
|
{
|
|
if(this.DisplayRectangle.Width==0 || this.DisplayRectangle.Height==0)
|
|
return;
|
|
|
|
Size closeButtonSize = Size.Empty;
|
|
if (m_CloseButton != null)
|
|
closeButtonSize = m_CloseButton.Size;
|
|
if(m_Style==eBallonStyle.Balloon)
|
|
{
|
|
Rectangle client=new Rectangle(m_CornerSize/2,m_CornerSize/2,this.Width-m_CornerSize,this.Height-m_CornerSize);
|
|
if(m_TipPosition==eTipPosition.Bottom)
|
|
client.Height-=m_TipLength;
|
|
else if(m_TipPosition==eTipPosition.Left)
|
|
{
|
|
client.X+=m_TipLength;
|
|
client.Width-=m_TipLength;
|
|
}
|
|
else if(m_TipPosition==eTipPosition.Right)
|
|
client.Width-=m_TipLength;
|
|
else
|
|
{
|
|
// TOP
|
|
client.Y+=m_TipLength;
|
|
client.Height-=m_TipLength;
|
|
}
|
|
|
|
System.Drawing.Size imageSize=System.Drawing.Size.Empty;
|
|
if(m_CaptionIcon!=null)
|
|
imageSize=Dpi.ImageSize(m_CaptionIcon.Size);
|
|
else if(m_CaptionImage!=null)
|
|
imageSize=Dpi.ImageSize(m_CaptionImage.Size);
|
|
|
|
m_CaptionRectangle=client;
|
|
if(!imageSize.IsEmpty)
|
|
{
|
|
m_CaptionRectangle.X+=(imageSize.Width+IMAGETEXT_SPACING);
|
|
m_CaptionRectangle.Width-=(imageSize.Width+IMAGETEXT_SPACING);
|
|
}
|
|
|
|
// Calculates position of the close button if visible
|
|
if(m_CloseButton!=null)
|
|
{
|
|
m_CloseButton.Location = new Point(client.Right - closeButtonSize.Width, client.Top);
|
|
m_CaptionRectangle.Width-=(closeButtonSize.Width+TEXTCLOSE_SPACING);
|
|
}
|
|
|
|
// Calculates caption text rectangle height
|
|
Font font=m_CaptionFont;
|
|
if(font==null)
|
|
font=this.Font;
|
|
Graphics g=this.CreateGraphics();
|
|
try
|
|
{
|
|
eTextFormat format = eTextFormat.Default | eTextFormat.WordBreak;
|
|
if (m_CaptionAlignment == StringAlignment.Center)
|
|
format = eTextFormat.HorizontalCenter;
|
|
else if (m_CaptionAlignment == StringAlignment.Far)
|
|
format = eTextFormat.Right;
|
|
Size strSize = Size.Empty;
|
|
if (_CaptionTextMarkup != null)
|
|
strSize = ResizeCaptionMarkup(g, m_CaptionRectangle.Width);
|
|
else
|
|
strSize = TextDrawing.MeasureString(g,(m_CaptionText!=""?m_CaptionText:" "),font,m_CaptionRectangle.Width,format);
|
|
m_CaptionRectangle.Height=strSize.Height;
|
|
}
|
|
finally
|
|
{
|
|
g.Dispose();
|
|
}
|
|
|
|
// Calculates position of the image rectangle
|
|
if(!imageSize.IsEmpty)
|
|
{
|
|
m_CaptionImageRectangle=new Rectangle(client.X,client.Y,imageSize.Width,imageSize.Height);
|
|
if(m_CaptionRectangle.Height>imageSize.Height)
|
|
m_CaptionImageRectangle.Y+=(int)(m_CaptionRectangle.Height-imageSize.Height)/2;
|
|
else if(imageSize.Height>m_CaptionRectangle.Height)
|
|
m_CaptionRectangle.Y+=(int)(imageSize.Height-m_CaptionRectangle.Height)/2;
|
|
|
|
}
|
|
else if(m_CloseButton!=null && closeButtonSize.Height>m_CaptionRectangle.Height)
|
|
m_CaptionRectangle.Y+=(int)(closeButtonSize.Height-m_CaptionRectangle.Height)/2;
|
|
|
|
// Calculates the rectangle for balloon text
|
|
if(m_CaptionRectangle.Bottom>m_CaptionImageRectangle.Bottom)
|
|
m_TextRectangle=new Rectangle(client.X,m_CaptionRectangle.Bottom+CAPTIONTEXT_VSPACING,client.Width,client.Bottom-(m_CaptionRectangle.Bottom+CAPTIONTEXT_VSPACING));
|
|
else
|
|
m_TextRectangle=new Rectangle(client.X,m_CaptionImageRectangle.Bottom+CAPTIONTEXT_VSPACING,client.Width,client.Bottom-(m_CaptionImageRectangle.Bottom+CAPTIONTEXT_VSPACING));
|
|
|
|
// Calculates and sets the balloon window region
|
|
GraphicsPath path=this.GetBalloonPath(this.DisplayRectangle);
|
|
GraphicsPath tmpPath = (GraphicsPath)path.Clone();
|
|
tmpPath.Widen(Pens.Black);
|
|
Region region = new Region(tmpPath);
|
|
region.Union(path);
|
|
this.Region=region;
|
|
path.Dispose();
|
|
tmpPath.Dispose();
|
|
}
|
|
else
|
|
{
|
|
Rectangle client=this.GetAlertClientRect();
|
|
System.Drawing.Size imageSize=System.Drawing.Size.Empty;
|
|
|
|
if(m_CaptionIcon!=null)
|
|
imageSize=Dpi.ImageSize(m_CaptionIcon.Size);
|
|
else if(m_CaptionImage!=null)
|
|
imageSize=Dpi.ImageSize(m_CaptionImage.Size);
|
|
|
|
m_CaptionRectangle=client;
|
|
if(!imageSize.IsEmpty)
|
|
{
|
|
m_CaptionRectangle.X+=(imageSize.Width+IMAGETEXT_SPACING*2);
|
|
m_CaptionRectangle.Width-=(imageSize.Width+IMAGETEXT_SPACING*2);
|
|
}
|
|
|
|
// Calculates position of the close button if visible
|
|
if(m_CloseButton!=null)
|
|
{
|
|
m_CloseButton.Location=new Point(client.Right-m_CloseButton.Bounds.Width-CAPTIONALERT_VSPACING,client.Top);
|
|
m_CaptionRectangle.Width-=(closeButtonSize.Width+TEXTCLOSE_SPACING+CAPTIONALERT_VSPACING);
|
|
}
|
|
|
|
// Calculates caption text rectangle height
|
|
Font font=m_CaptionFont;
|
|
if(font==null)
|
|
font=this.Font;
|
|
Graphics g=this.CreateGraphics();
|
|
try
|
|
{
|
|
eTextFormat format = eTextFormat.Default | eTextFormat.WordBreak;
|
|
if (m_CaptionAlignment == StringAlignment.Center)
|
|
format = eTextFormat.HorizontalCenter;
|
|
else if (m_CaptionAlignment == StringAlignment.Far)
|
|
format = eTextFormat.Right;
|
|
Size strSize = TextDrawing.MeasureString(g, (m_CaptionText != "" ? m_CaptionText : " "), font, m_CaptionRectangle.Width, format);
|
|
m_CaptionRectangle.Height=strSize.Height;
|
|
}
|
|
finally
|
|
{
|
|
g.Dispose();
|
|
}
|
|
|
|
// Calculates position of the image rectangle
|
|
if(!imageSize.IsEmpty)
|
|
{
|
|
m_CaptionImageRectangle=new Rectangle(client.X+IMAGETEXT_SPACING,client.Y,imageSize.Width,imageSize.Height);
|
|
if(m_CaptionRectangle.Height>imageSize.Height)
|
|
m_CaptionImageRectangle.Y+=(int)(m_CaptionRectangle.Height-imageSize.Height)/2;
|
|
else if(imageSize.Height>m_CaptionRectangle.Height)
|
|
{
|
|
m_CaptionRectangle.Y+=(int)(imageSize.Height+-m_CaptionRectangle.Height)/2;
|
|
}
|
|
|
|
}
|
|
else if(m_CloseButton!=null && closeButtonSize.Height>m_CaptionRectangle.Height)
|
|
m_CaptionRectangle.Y+=(int)(closeButtonSize.Height-m_CaptionRectangle.Height)/2;
|
|
|
|
m_CaptionRectangle.Offset(0,CAPTIONALERT_VSPACING);
|
|
m_CaptionImageRectangle.Offset(0,CAPTIONALERT_VSPACING);
|
|
|
|
if(m_CloseButton!=null)
|
|
{
|
|
m_CloseButton.Location=new Point(m_CloseButton.Location.X,m_CaptionRectangle.Y+(m_CaptionRectangle.Height-closeButtonSize.Height)/2);
|
|
}
|
|
|
|
|
|
// Calculates the rectangle for balloon text
|
|
if(m_CaptionRectangle.Bottom>m_CaptionImageRectangle.Bottom)
|
|
m_TextRectangle=new Rectangle(client.X,m_CaptionRectangle.Bottom+CAPTIONTEXT_VSPACING*4,client.Width,client.Bottom-(m_CaptionRectangle.Bottom+CAPTIONTEXT_VSPACING*4));
|
|
else
|
|
m_TextRectangle=new Rectangle(client.X,m_CaptionImageRectangle.Bottom+CAPTIONTEXT_VSPACING*4,client.Width,client.Bottom-(m_CaptionImageRectangle.Bottom+CAPTIONTEXT_VSPACING*4));
|
|
|
|
this.Region=new Region(this.DisplayRectangle);
|
|
}
|
|
}
|
|
|
|
private Rectangle GetAlertClientRect()
|
|
{
|
|
Rectangle r = new Rectangle(0, 0, this.Width, this.Height); // this.DisplayRectangle;
|
|
r.Inflate(-4,-4);
|
|
return r;
|
|
}
|
|
|
|
private GraphicsPath GetBalloonPath(Rectangle rect)
|
|
{
|
|
GraphicsPath path = new GraphicsPath();
|
|
|
|
Rectangle clipBounds=rect;
|
|
Rectangle balloonBounds=clipBounds;
|
|
int cornerDiameter=m_CornerSize*2;
|
|
Matrix matrix=new Matrix();
|
|
Point[] anchorPoints=new Point[3];
|
|
int tipOffset=m_TipOffset;
|
|
|
|
balloonBounds.Size=new Size(balloonBounds.Width-1,balloonBounds.Height-1);
|
|
|
|
bool adjustOffset = false;
|
|
if(m_TipPosition==eTipPosition.Bottom)
|
|
{
|
|
adjustOffset=true;
|
|
matrix.Translate(balloonBounds.Width, balloonBounds.Height);
|
|
matrix.Rotate(180);
|
|
}
|
|
else if (m_TipPosition == eTipPosition.Left && this.RightToLeft == RightToLeft.No ||
|
|
m_TipPosition == eTipPosition.Right && this.RightToLeft == RightToLeft.Yes)
|
|
{
|
|
adjustOffset = true;
|
|
balloonBounds.Size=new Size(balloonBounds.Height, balloonBounds.Width);
|
|
matrix.Translate(0, balloonBounds.Width);
|
|
matrix.Rotate(-90);
|
|
}
|
|
else if(m_TipPosition==eTipPosition.Right && this.RightToLeft == RightToLeft.No ||
|
|
m_TipPosition == eTipPosition.Left && this.RightToLeft == RightToLeft.Yes)
|
|
{
|
|
balloonBounds.Size=new Size(balloonBounds.Height, balloonBounds.Width);
|
|
matrix.Translate(balloonBounds.Height, 0);
|
|
matrix.Rotate(90);
|
|
}
|
|
|
|
int balloonEdgeCenter =((int)(balloonBounds.Width-(m_CornerSize*2))/2)+1;
|
|
int offsetFromEdge = m_CornerSize;
|
|
if(adjustOffset)
|
|
{
|
|
tipOffset=(balloonBounds.Width-(offsetFromEdge*2)-m_TipOffset)+1;
|
|
}
|
|
if(tipOffset<balloonEdgeCenter)
|
|
{
|
|
anchorPoints[0]=new Point(tipOffset+offsetFromEdge,balloonBounds.Y+m_TipLength);
|
|
anchorPoints[1]=new Point(tipOffset+offsetFromEdge,balloonBounds.Y);
|
|
anchorPoints[2]=new Point(tipOffset+m_TipLength+offsetFromEdge,balloonBounds.Y+m_TipLength);
|
|
}
|
|
else if(tipOffset>balloonEdgeCenter)
|
|
{
|
|
anchorPoints[0]=new Point(tipOffset-m_TipLength+offsetFromEdge,balloonBounds.Y+m_TipLength);
|
|
anchorPoints[1]=new Point(tipOffset+offsetFromEdge,balloonBounds.Y);
|
|
anchorPoints[2]=new Point(tipOffset+offsetFromEdge,balloonBounds.Y+m_TipLength);
|
|
}
|
|
else
|
|
{
|
|
anchorPoints[0]=new Point(tipOffset-m_TipLength+offsetFromEdge,balloonBounds.Y+m_TipLength);
|
|
anchorPoints[1]=new Point(tipOffset+offsetFromEdge,balloonBounds.Y);
|
|
anchorPoints[2]=new Point(tipOffset+m_TipLength+offsetFromEdge,balloonBounds.Y+m_TipLength);
|
|
}
|
|
|
|
path.AddArc(balloonBounds.Left,balloonBounds.Top+m_TipLength,cornerDiameter, cornerDiameter,180, 90);
|
|
|
|
path.AddLine(anchorPoints[0],anchorPoints[1]);
|
|
path.AddLine(anchorPoints[1],anchorPoints[2]);
|
|
|
|
path.AddArc(balloonBounds.Width-cornerDiameter,balloonBounds.Top+m_TipLength,cornerDiameter, cornerDiameter, -90, 90);
|
|
path.AddArc(balloonBounds.Width-cornerDiameter,balloonBounds.Bottom-cornerDiameter,cornerDiameter, cornerDiameter, 0, 90);
|
|
path.AddArc(balloonBounds.Left, balloonBounds.Bottom-cornerDiameter,cornerDiameter, cornerDiameter, 90, 90);
|
|
|
|
path.CloseFigure();
|
|
|
|
path.Transform(matrix);
|
|
|
|
return path;
|
|
}
|
|
|
|
private void PaintBackgroundInternal(Graphics g)
|
|
{
|
|
Rectangle r=this.ClientRectangle;
|
|
if(r.Width==0 || r.Height==0)
|
|
return;
|
|
|
|
if(m_BackColor2.IsEmpty)
|
|
{
|
|
using(SolidBrush brush=new SolidBrush(this.BackColor))
|
|
g.FillRectangle(brush,r);
|
|
}
|
|
else
|
|
{
|
|
using(LinearGradientBrush gradient=BarFunctions.CreateLinearGradientBrush(r,this.BackColor,m_BackColor2,m_BackColorGradientAngle))
|
|
{
|
|
if(m_Style==eBallonStyle.Alert)
|
|
{
|
|
Blend b=new Blend(4);
|
|
b.Positions=new float[]{0f,.25f,.4f,.5f,.5f,.85f,.85f,1f};
|
|
b.Factors=new float[] {0f,1f,1f,0f,0f,0f,0f,1f};
|
|
gradient.Blend=b;
|
|
}
|
|
g.FillRectangle(gradient,r);
|
|
}
|
|
}
|
|
|
|
if(this.BackgroundImage==null)
|
|
return;
|
|
|
|
// System.Drawing.Imaging.ImageAttributes imageAtt=null;
|
|
//
|
|
// if(m_BackgroundImageAlpha!=255)
|
|
// {
|
|
// System.Drawing.Imaging.ColorMatrix colorMatrix=new System.Drawing.Imaging.ColorMatrix();
|
|
// colorMatrix.Matrix33=255-m_BackgroundImageAlpha;
|
|
// imageAtt=new System.Drawing.Imaging.ImageAttributes();
|
|
// imageAtt.SetColorMatrix(colorMatrix,System.Drawing.Imaging.ColorMatrixFlag.Default,System.Drawing.Imaging.ColorAdjustType.Bitmap);
|
|
// }
|
|
|
|
BarFunctions.PaintBackgroundImage(g,r,this.BackgroundImage,m_BackgroundImagePosition,m_BackgroundImageAlpha);
|
|
|
|
// switch(m_BackgroundImagePosition)
|
|
// {
|
|
// case eBackgroundImagePosition.Stretch:
|
|
// {
|
|
// if(imageAtt!=null)
|
|
// g.DrawImage(this.BackgroundImage,r,0,0,this.BackgroundImage.Width,this.BackgroundImage.Height,GraphicsUnit.Pixel,imageAtt);
|
|
// else
|
|
// g.DrawImage(this.BackgroundImage,r,0,0,this.BackgroundImage.Width,this.BackgroundImage.Height,GraphicsUnit.Pixel);
|
|
// break;
|
|
// }
|
|
// case eBackgroundImagePosition.Center:
|
|
// {
|
|
// Rectangle destRect=new Rectangle(r.X,r.Y,this.BackgroundImage.Width,this.BackgroundImage.Height);
|
|
// if(r.Width>this.BackgroundImage.Width)
|
|
// destRect.X+=(r.Width-this.BackgroundImage.Width)/2;
|
|
// if(r.Height>this.BackgroundImage.Height)
|
|
// destRect.Y+=(r.Height-this.BackgroundImage.Height)/2;
|
|
// if(imageAtt!=null)
|
|
// g.DrawImage(this.BackgroundImage,destRect,0,0,this.BackgroundImage.Width,this.BackgroundImage.Height,GraphicsUnit.Pixel,imageAtt);
|
|
// else
|
|
// g.DrawImage(this.BackgroundImage,destRect,0,0,this.BackgroundImage.Width,this.BackgroundImage.Height,GraphicsUnit.Pixel);
|
|
// break;
|
|
// }
|
|
// case eBackgroundImagePosition.TopLeft:
|
|
// case eBackgroundImagePosition.TopRight:
|
|
// case eBackgroundImagePosition.BottomLeft:
|
|
// case eBackgroundImagePosition.BottomRight:
|
|
// {
|
|
// Rectangle destRect=new Rectangle(r.X,r.Y,this.BackgroundImage.Width,this.BackgroundImage.Height);
|
|
// if(m_BackgroundImagePosition==eBackgroundImagePosition.TopRight)
|
|
// destRect.X=r.Right-this.BackgroundImage.Width;
|
|
// else if(m_BackgroundImagePosition==eBackgroundImagePosition.BottomLeft)
|
|
// destRect.Y=r.Bottom-this.BackgroundImage.Height;
|
|
// else if(m_BackgroundImagePosition==eBackgroundImagePosition.BottomRight)
|
|
// {
|
|
// destRect.Y=r.Bottom-this.BackgroundImage.Height;
|
|
// destRect.X=r.Right-this.BackgroundImage.Width;
|
|
// }
|
|
//
|
|
// if(imageAtt!=null)
|
|
// g.DrawImage(this.BackgroundImage,destRect,0,0,this.BackgroundImage.Width,this.BackgroundImage.Height,GraphicsUnit.Pixel,imageAtt);
|
|
// else
|
|
// g.DrawImage(this.BackgroundImage,destRect,0,0,this.BackgroundImage.Width,this.BackgroundImage.Height,GraphicsUnit.Pixel);
|
|
// break;
|
|
// }
|
|
// case eBackgroundImagePosition.Tile:
|
|
// {
|
|
// if(imageAtt!=null)
|
|
// {
|
|
// if(r.Width>this.BackgroundImage.Width || r.Height>this.BackgroundImage.Height)
|
|
// {
|
|
// int x=r.X,y=r.Y;
|
|
// while(y<r.Bottom)
|
|
// {
|
|
// while(x<r.Right)
|
|
// {
|
|
// Rectangle destRect=new Rectangle(x,y,this.BackgroundImage.Width,this.BackgroundImage.Height);
|
|
// if(destRect.Right>r.Right)
|
|
// destRect.Width=destRect.Width-(destRect.Right-r.Right);
|
|
// if(destRect.Bottom>r.Bottom)
|
|
// destRect.Height=destRect.Height-(destRect.Bottom-r.Bottom);
|
|
// g.DrawImage(this.BackgroundImage,destRect,0,0,destRect.Width,destRect.Height,GraphicsUnit.Pixel,imageAtt);
|
|
// x+=this.BackgroundImage.Width;
|
|
// }
|
|
// x=r.X;
|
|
// y+=this.BackgroundImage.Height;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// g.DrawImage(this.BackgroundImage,new Rectangle(0,0,this.BackgroundImage.Width,this.BackgroundImage.Height),0,0,this.BackgroundImage.Width,this.BackgroundImage.Height,GraphicsUnit.Pixel,imageAtt);
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// TextureBrush brush=new TextureBrush(this.BackgroundImage); //,r);
|
|
// brush.WrapMode=System.Drawing.Drawing2D.WrapMode.Tile;
|
|
// g.FillRectangle(brush,r);
|
|
// brush.Dispose();
|
|
// }
|
|
// break;
|
|
// }
|
|
// }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the target gradient background color.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates the target gradient background color."),Category("Style")]
|
|
public Color BackColor2
|
|
{
|
|
get {return m_BackColor2;}
|
|
set
|
|
{
|
|
m_BackColor2=value;
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
[Browsable(false),EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeBackColor2()
|
|
{
|
|
return !m_BackColor2.IsEmpty;
|
|
}
|
|
[Browsable(false),EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetBackColor2()
|
|
{
|
|
m_BackColor2=Color.Empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets gradient fill angle.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates gradient fill angle."),Category("Style"),DefaultValue(90)]
|
|
public int BackColorGradientAngle
|
|
{
|
|
get {return m_BackColorGradientAngle;}
|
|
set
|
|
{
|
|
if(value!=m_BackColorGradientAngle)
|
|
{
|
|
m_BackColorGradientAngle=value;
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Specifies the transparency of background image.
|
|
/// </summary>
|
|
[Browsable(true),DevCoBrowsable(true),Category("Appearance"),DefaultValue(255),Description("Specifies the transparency of background image.")]
|
|
public int BackgroundImageAlpha
|
|
{
|
|
get {return m_BackgroundImageAlpha;}
|
|
set
|
|
{
|
|
if(value<0)
|
|
value=0;
|
|
else if(value>255)
|
|
value=255;
|
|
if(m_BackgroundImageAlpha!=value)
|
|
{
|
|
m_BackgroundImageAlpha=value;
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Specifies background image position when container is larger than image.
|
|
/// </summary>
|
|
[Browsable(true),DevCoBrowsable(true),Category("Appearance"),DefaultValue(eBackgroundImagePosition.Stretch),Description("Specifies background image position when container is larger than image.")]
|
|
public eBackgroundImagePosition BackgroundImagePosition
|
|
{
|
|
get {return m_BackgroundImagePosition;}
|
|
set
|
|
{
|
|
if(m_BackgroundImagePosition!=value)
|
|
{
|
|
m_BackgroundImagePosition=value;
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the border color..
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates border color."),Category("Style")]
|
|
public Color BorderColor
|
|
{
|
|
get {return m_BorderColor;}
|
|
set
|
|
{
|
|
m_BorderColor=value;
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
[Browsable(false),EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeBorderColor()
|
|
{
|
|
return m_BorderColor!=SystemColors.InfoText;
|
|
}
|
|
[Browsable(false),EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetBorderColor()
|
|
{
|
|
m_BorderColor=SystemColors.InfoText;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies balloon style.
|
|
/// </summary>
|
|
[Browsable(true),DevCoBrowsable(true),Category("Style"),DefaultValue(eBallonStyle.Balloon),Description("Specifies balloon style.")]
|
|
public eBallonStyle Style
|
|
{
|
|
get {return m_Style;}
|
|
set
|
|
{
|
|
m_Style=value;
|
|
if(m_Style==eBallonStyle.Alert)
|
|
{
|
|
this.BackColor=Color.FromArgb(207,221,244);
|
|
this.BackColor2=Color.White;
|
|
this.ForeColor=Color.FromArgb(102,114,196);
|
|
m_TextAlignment=StringAlignment.Center;
|
|
}
|
|
else if (m_Style == eBallonStyle.Office2007Alert)
|
|
{
|
|
Office2007ColorTable ct = GetOffice2007ColorTable();
|
|
ColorScheme cs = ct.LegacyColors;
|
|
if (ct.SuperTooltip.BackgroundColors.IsEmpty)
|
|
{
|
|
this.BackColor = cs.PanelBackground;
|
|
this.BackColor2 = cs.PanelBackground2;
|
|
this.ForeColor = cs.PanelText;
|
|
}
|
|
else
|
|
{
|
|
this.BackColor = ct.SuperTooltip.BackgroundColors.Start;
|
|
this.BackColor2 = ct.SuperTooltip.BackgroundColors.End;
|
|
this.ForeColor = ct.SuperTooltip.TextColor;
|
|
}
|
|
m_BorderColor = cs.PanelBorder;
|
|
m_TextAlignment = StringAlignment.Near;
|
|
}
|
|
else
|
|
{
|
|
m_TextAlignment = StringAlignment.Near;
|
|
m_BorderColor = SystemColors.InfoText;
|
|
}
|
|
if(m_ShowCloseButton)
|
|
this.CreateCloseButton();
|
|
this.RecalcLayout();
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
|
|
private Office2007ColorTable GetOffice2007ColorTable()
|
|
{
|
|
Office2007Renderer r = GlobalManager.Renderer as Office2007Renderer;
|
|
if (r != null)
|
|
return r.ColorTable;
|
|
return new Office2007ColorTable();
|
|
}
|
|
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
|
{
|
|
base.OnMouseDown(e);
|
|
if(m_CloseButton!=null)
|
|
m_CloseButton.OnMouseDown(e);
|
|
if(this.Focused)
|
|
this.Focus();
|
|
}
|
|
|
|
protected override void OnMouseMove(MouseEventArgs e)
|
|
{
|
|
base.OnMouseMove(e);
|
|
if(m_CloseButton!=null)
|
|
m_CloseButton.OnMouseMove(e);
|
|
}
|
|
|
|
protected override void OnMouseUp(MouseEventArgs e)
|
|
{
|
|
base.OnMouseUp(e);
|
|
if(m_CloseButton!=null)
|
|
m_CloseButton.OnMouseUp(e);
|
|
}
|
|
|
|
protected override void OnMouseLeave(EventArgs e)
|
|
{
|
|
base.OnMouseLeave(e);
|
|
if(m_CloseButton!=null)
|
|
m_CloseButton.OnMouseLeave(e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether the Close button is displayed.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates whether the Close button is displayed."),Category("Behavior"),DefaultValue(true)]
|
|
public bool ShowCloseButton
|
|
{
|
|
get {return m_ShowCloseButton;}
|
|
set
|
|
{
|
|
if(value!=m_ShowCloseButton)
|
|
{
|
|
m_ShowCloseButton=value;
|
|
OnShowCloseButtonChanged();
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnShowCloseButtonChanged()
|
|
{
|
|
if(m_ShowCloseButton)
|
|
{
|
|
CreateCloseButton();
|
|
RecalcLayout();
|
|
}
|
|
else
|
|
{
|
|
m_CloseButton=null;
|
|
}
|
|
}
|
|
|
|
private void CreateCloseButton()
|
|
{
|
|
if (m_CloseButtonNormal != null)
|
|
{
|
|
m_CloseButton = new ImageButton(this, new Rectangle(0, 0, Dpi.Width(m_CloseButtonNormal.Width), Dpi.Height(m_CloseButtonNormal.Height)));
|
|
if (m_CloseButton.Normal != null)
|
|
{
|
|
m_CloseButton.Normal.Dispose();
|
|
m_CloseButton.Normal = null;
|
|
}
|
|
m_CloseButton.Normal = m_CloseButtonNormal;
|
|
if (m_CloseButton.Hover != null)
|
|
{
|
|
m_CloseButton.Hover.Dispose();
|
|
m_CloseButton.Hover = null;
|
|
}
|
|
m_CloseButton.Hover = m_CloseButtonHot;
|
|
if (m_CloseButton.Pressed != null)
|
|
{
|
|
m_CloseButton.Pressed.Dispose();
|
|
m_CloseButton.Pressed = null;
|
|
}
|
|
m_CloseButton.Pressed = m_CloseButtonPressed;
|
|
}
|
|
else // Default Image Size is 18x18
|
|
{
|
|
if (m_Style == eBallonStyle.Balloon)
|
|
{
|
|
m_CloseButton = new ImageButton(this, new Rectangle(0, 0, Dpi.Width18, Dpi.Height18));
|
|
m_CloseButton.Normal = BarFunctions.LoadBitmap("BalloonImages.BalloonNormal.png");
|
|
m_CloseButton.Hover = BarFunctions.LoadBitmap("BalloonImages.BalloonHot.png");
|
|
m_CloseButton.Pressed = BarFunctions.LoadBitmap("BalloonImages.BalloonPress.png");
|
|
}
|
|
else
|
|
{
|
|
m_CloseButton = new ImageButton(this, new Rectangle(0, 0, Dpi.Width13, Dpi.Height13));
|
|
m_CloseButton.Normal = BarFunctions.LoadBitmap("BalloonImages.AlertNormal.png");
|
|
m_CloseButton.Hover = BarFunctions.LoadBitmap("BalloonImages.AlertHot.png");
|
|
m_CloseButton.Pressed = BarFunctions.LoadBitmap("BalloonImages.AlertPress.png");
|
|
}
|
|
}
|
|
m_CloseButton.Click+=new EventHandler(this.CloseButtonClickInternal);
|
|
}
|
|
|
|
private void CloseButtonClickInternal(object sender, EventArgs e)
|
|
{
|
|
if(CloseButtonClick!=null)
|
|
CloseButtonClick(this,new EventArgs());
|
|
if(m_AutoClose)
|
|
{
|
|
this.Hide();
|
|
this.Close();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the animation type used to display Alert type balloon.
|
|
/// </summary>
|
|
[Browsable(true),Description("Gets or sets the animation type used to display Alert type balloon."),Category("Behavior"),DefaultValue(eAlertAnimation.BottomToTop)]
|
|
public eAlertAnimation AlertAnimation
|
|
{
|
|
get {return m_AlertAnimation;}
|
|
set {m_AlertAnimation=value;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the total time in milliseconds alert animation takes.
|
|
/// Default value is 200.
|
|
/// </summary>
|
|
[Browsable(true),Description("Gets or sets the total time in milliseconds alert animation takes."),Category("Behavior"),DefaultValue(200)]
|
|
public int AlertAnimationDuration
|
|
{
|
|
get {return m_AlertAnimationDuration;}
|
|
set {m_AlertAnimationDuration=value;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether balloon will close automatically when user click the close button.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates whether balloon will close automatically when user click the close button."),Category("Behavior"),DefaultValue(true)]
|
|
public bool AutoClose
|
|
{
|
|
get {return m_AutoClose;}
|
|
set {m_AutoClose=value;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets time period in seconds after balloon closes automatically.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates time period in seconds after balloon closes automatically."),Category("Behavior"),DefaultValue(0)]
|
|
public int AutoCloseTimeOut
|
|
{
|
|
get {return m_AutoCloseTimeOut;}
|
|
set
|
|
{
|
|
m_AutoCloseTimeOut=value;
|
|
OnAutoCloseTimeOutChanged();
|
|
}
|
|
}
|
|
|
|
protected void OnAutoCloseTimeOutChanged()
|
|
{
|
|
if(m_AutoCloseTimeOut>0 && !this.DesignMode)
|
|
{
|
|
if(m_Timer==null)
|
|
m_Timer=new System.Windows.Forms.Timer(components);
|
|
m_Timer.Enabled=false;
|
|
m_Timer.Interval=m_AutoCloseTimeOut*1000;
|
|
m_Timer.Tick+=new EventHandler(this.AutoCloseTimeOutEllapsed);
|
|
if(this.Visible)
|
|
{
|
|
m_Timer.Enabled=true;
|
|
m_Timer.Start();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DestroyAutoCloseTimer();
|
|
}
|
|
}
|
|
|
|
protected virtual void AutoCloseTimeOutEllapsed(object sender, EventArgs e)
|
|
{
|
|
if(this.IsDisposed)
|
|
return;
|
|
DestroyAutoCloseTimer();
|
|
this.Hide();
|
|
this.Close();
|
|
}
|
|
|
|
private void DestroyAutoCloseTimer()
|
|
{
|
|
if(m_Timer!=null)
|
|
{
|
|
m_Timer.Enabled=false;
|
|
m_Timer.Tick-=new EventHandler(this.AutoCloseTimeOutEllapsed);
|
|
components.Remove(m_Timer);
|
|
m_Timer.Dispose();
|
|
m_Timer=null;
|
|
}
|
|
}
|
|
|
|
protected override void OnVisibleChanged(EventArgs e)
|
|
{
|
|
base.OnVisibleChanged(e);
|
|
if(this.Visible)
|
|
{
|
|
if(m_Timer!=null && !m_Timer.Enabled)
|
|
{
|
|
m_Timer.Enabled=true;
|
|
m_Timer.Start();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(m_Timer!=null && m_Timer.Enabled)
|
|
{
|
|
m_Timer.Stop();
|
|
m_Timer.Enabled=false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the custom image for Close Button.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates custom image for Close Button."),Category("Appearance")]
|
|
public Image CloseButtonNormal
|
|
{
|
|
get {return m_CloseButtonNormal;}
|
|
set
|
|
{
|
|
if(m_CloseButtonNormal!=value)
|
|
{
|
|
m_CloseButtonNormal=value;
|
|
OnShowCloseButtonChanged();
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the custom image for Close Button when mouse is over the button.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates custom image for Close Button when mouse is over the button."),Category("Appearance"),DefaultValue(null)]
|
|
public Image CloseButtonHot
|
|
{
|
|
get {return m_CloseButtonHot;}
|
|
set
|
|
{
|
|
if(m_CloseButtonHot!=value)
|
|
{
|
|
m_CloseButtonHot=value;
|
|
OnShowCloseButtonChanged();
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the custom image for Close Button when button is pressed.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates custom image for Close Button when button is pressed."),Category("Appearance"),DefaultValue(null)]
|
|
public Image CloseButtonPressed
|
|
{
|
|
get {return m_CloseButtonPressed;}
|
|
set
|
|
{
|
|
if(m_CloseButtonPressed!=value)
|
|
{
|
|
m_CloseButtonPressed=value;
|
|
OnShowCloseButtonChanged();
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the Caption image.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates Caption image."),Category("Appearance"),DefaultValue(null)]
|
|
public Image CaptionImage
|
|
{
|
|
get {return m_CaptionImage;}
|
|
set
|
|
{
|
|
if(m_CaptionImage!=value)
|
|
{
|
|
m_CaptionImage=value;
|
|
this.RecalcLayout();
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the Caption icon. Icon is used to provide support for alpha-blended images in caption.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates Caption icon. Icon is used to provide support for alpha-blended images in caption."),Category("Appearance"),DefaultValue(null)]
|
|
public Icon CaptionIcon
|
|
{
|
|
get {return m_CaptionIcon;}
|
|
set
|
|
{
|
|
if(m_CaptionIcon!=value)
|
|
{
|
|
m_CaptionIcon=value;
|
|
this.RecalcLayout();
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
private CompositeImage ImageInternal
|
|
{
|
|
get
|
|
{
|
|
if(m_CaptionIcon!=null)
|
|
return new CompositeImage(m_CaptionIcon,false);
|
|
else if(m_CaptionImage!=null)
|
|
return new CompositeImage(m_CaptionImage,false);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the Caption font.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates Caption font."),Category("Appearance")]
|
|
public Font CaptionFont
|
|
{
|
|
get {return m_CaptionFont;}
|
|
set
|
|
{
|
|
if(m_CaptionFont!=value)
|
|
{
|
|
m_CaptionFont=value;
|
|
this.RecalcLayout();
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
private TextMarkup.BodyElement _CaptionTextMarkup = null;
|
|
/// <summary>
|
|
/// Gets or sets text displayed in caption.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates text displayed in caption."),Category("Appearance"),DefaultValue(""), Localizable(true)]
|
|
public string CaptionText
|
|
{
|
|
get {return m_CaptionText;}
|
|
set
|
|
{
|
|
if(m_CaptionText!=value)
|
|
{
|
|
m_CaptionText=value;
|
|
|
|
if (_CaptionTextMarkup != null)
|
|
{
|
|
_CaptionTextMarkup.MouseLeave(this);
|
|
_CaptionTextMarkup.HyperLinkClick -= TextMarkupLinkClicked;
|
|
_CaptionTextMarkup = null;
|
|
}
|
|
|
|
if (TextMarkup.MarkupParser.IsMarkup(ref m_CaptionText))
|
|
_CaptionTextMarkup = TextMarkup.MarkupParser.Parse(m_CaptionText);
|
|
|
|
if (_CaptionTextMarkup != null)
|
|
{
|
|
_CaptionTextMarkup.HyperLinkClick += TextMarkupLinkClicked;
|
|
}
|
|
|
|
this.RecalcLayout();
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets color of caption text.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates color of caption text"),Category("Appearance")]
|
|
public Color CaptionColor
|
|
{
|
|
get {return m_CaptionColor;}
|
|
set
|
|
{
|
|
if(m_CaptionColor!=value)
|
|
{
|
|
m_CaptionColor=value;
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or set position of the balloon tip.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates position of the balloon tip."),Category("Appearance"),DefaultValue(eTipPosition.Top)]
|
|
public eTipPosition TipPosition
|
|
{
|
|
get {return m_TipPosition;}
|
|
set
|
|
{
|
|
if(m_TipPosition!=value)
|
|
{
|
|
m_TipPosition=value;
|
|
this.RecalcLayout();
|
|
if(TipPositionChanged!=null)
|
|
TipPositionChanged(this,new EventArgs());
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void InternalTipPositionChanged(eTipPosition newValue)
|
|
{
|
|
if(this.Controls.Count==0 || this.Style!=eBallonStyle.Balloon)
|
|
return;
|
|
if(newValue==eTipPosition.Top && m_TipPosition==eTipPosition.Bottom)
|
|
{
|
|
foreach(Control control in this.Controls)
|
|
{
|
|
control.Top+=m_TipLength;
|
|
}
|
|
}
|
|
else if(newValue==eTipPosition.Bottom && m_TipPosition==eTipPosition.Top)
|
|
{
|
|
foreach(Control control in this.Controls)
|
|
{
|
|
control.Top-=m_TipLength;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets tip distance from the edge of the balloon.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates tip distance from the edge of the balloon."),Category("Appearance"),DefaultValue(32)]
|
|
public int TipOffset
|
|
{
|
|
get {return m_TipOffset;}
|
|
set
|
|
{
|
|
if(m_TipOffset!=value)
|
|
{
|
|
if(value<m_CornerSize)
|
|
value=m_CornerSize+1;
|
|
else if((m_TipPosition==eTipPosition.Top || m_TipPosition==eTipPosition.Bottom) && value>this.Width-m_CornerSize-m_TipLength)
|
|
value=this.Width-m_CornerSize-m_TipLength;
|
|
else if((m_TipPosition==eTipPosition.Left || m_TipPosition==eTipPosition.Right) && value>this.Height-m_CornerSize-m_TipLength)
|
|
value=this.Height-m_CornerSize-m_TipLength;
|
|
|
|
m_TipOffset=value;
|
|
this.RecalcLayout();
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns length of the tip.
|
|
/// </summary>
|
|
[Browsable(false),Description("Returns tip length"),Category("Appearance")]
|
|
public int TipLength
|
|
{
|
|
get {return m_TipLength;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays balloon using control to automatically calculate balloon location. Method is usually used display balloon that is showing information for the certain control.
|
|
/// </summary>
|
|
/// <param name="referenceControl">Control used for balloon positioning.</param>
|
|
public void Show(Control referenceControl)
|
|
{
|
|
this.Show(referenceControl,true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays balloon using control to automatically calculate balloon location. Method is usually used display balloon that is showing information for the certain control.
|
|
/// </summary>
|
|
/// <param name="referenceControl">Control used for balloon positioning.</param>
|
|
/// <param name="balloonFocus">Indicates whether balloon receives input focus.</param>
|
|
public void Show(Control referenceControl, bool balloonFocus)
|
|
{
|
|
if(referenceControl==null)
|
|
{
|
|
this.Show();
|
|
return;
|
|
}
|
|
Point scrLocCtrl=Point.Empty;
|
|
|
|
if(referenceControl.Parent!=null)
|
|
scrLocCtrl=referenceControl.Parent.PointToScreen(referenceControl.Location);
|
|
else
|
|
scrLocCtrl=referenceControl.Location;
|
|
|
|
this.Show(new Rectangle(scrLocCtrl,referenceControl.Size),balloonFocus);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays balloon using rectangle to automatically calculate balloon location. Method is usually used display balloon that is showing information for the certain screen region.
|
|
/// </summary>
|
|
/// <param name="referenceScreenRect">Rectangle in screen coordinates used for balloon positioning.</param>
|
|
/// <param name="balloonFocus">Indicates whether balloon receives input focus.</param>
|
|
public void Show(Rectangle referenceScreenRect, bool balloonFocus)
|
|
{
|
|
if(referenceScreenRect.IsEmpty)
|
|
{
|
|
this.Show();
|
|
return;
|
|
}
|
|
|
|
int tipPositionOffset=m_TipLength+m_CornerSize*3;
|
|
int tipOffset=m_TipLength/2+m_CornerSize*3;
|
|
Point balloonLocation=Point.Empty;
|
|
ScreenInformation screen=BarFunctions.ScreenFromPoint(referenceScreenRect.Location);
|
|
|
|
if(referenceScreenRect.X+referenceScreenRect.Width/2+this.Width>screen.WorkingArea.Right)
|
|
{
|
|
balloonLocation.X=referenceScreenRect.X+referenceScreenRect.Width/2-this.Width+tipPositionOffset;
|
|
tipOffset=this.Width-tipPositionOffset;
|
|
}
|
|
else
|
|
balloonLocation.X=referenceScreenRect.X+referenceScreenRect.Width/2-tipPositionOffset;
|
|
|
|
if(referenceScreenRect.Y+referenceScreenRect.Height+this.Height>screen.WorkingArea.Bottom)
|
|
{
|
|
balloonLocation.Y=referenceScreenRect.Y-this.Height;
|
|
InternalTipPositionChanged(eTipPosition.Bottom);
|
|
this.TipPosition=eTipPosition.Bottom;
|
|
}
|
|
else
|
|
{
|
|
balloonLocation.Y=referenceScreenRect.Y+referenceScreenRect.Height;
|
|
InternalTipPositionChanged(eTipPosition.Top);
|
|
this.TipPosition=eTipPosition.Top;
|
|
}
|
|
|
|
this.TipOffset=tipOffset;
|
|
this.Location=balloonLocation;
|
|
this.Show(balloonFocus);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays balloon using item to automatically calculate balloon location. Method is usually used display balloon that is showing information for the certain item.
|
|
/// </summary>
|
|
/// <param name="item">Item used for balloon positioning.</param>
|
|
/// <param name="balloonFocus">Indicates whether balloon receives input focus.</param>
|
|
public void Show(BaseItem item, bool balloonFocus)
|
|
{
|
|
if(item==null || item.ContainerControl==null)
|
|
{
|
|
this.Show();
|
|
return;
|
|
}
|
|
Point loc=((Control)item.ContainerControl).PointToScreen(item.DisplayRectangle.Location);
|
|
this.Show(new Rectangle(loc,item.DisplayRectangle.Size),balloonFocus);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display balloon.
|
|
/// </summary>
|
|
/// <param name="balloonFocus">Indicates whether balloon receives input focus.</param>
|
|
public void Show(bool balloonFocus)
|
|
{
|
|
Rectangle rEnd=new Rectangle(this.Location,this.Size);
|
|
Rectangle rStart=GetAnimationRectangle();
|
|
|
|
if(!balloonFocus)
|
|
{
|
|
if(this.TopMost)
|
|
{
|
|
this.TopMost=false;
|
|
NativeFunctions.SetWindowPos(this.Handle,new IntPtr(NativeFunctions.HWND_TOP),0,0,0,0,NativeFunctions.SWP_SHOWWINDOW | NativeFunctions.SWP_NOACTIVATE | NativeFunctions.SWP_NOMOVE | NativeFunctions.SWP_NOSIZE);
|
|
this.TopMost=true;
|
|
}
|
|
else
|
|
NativeFunctions.SetWindowPos(this.Handle,new IntPtr(NativeFunctions.HWND_TOP),0,0,0,0,NativeFunctions.SWP_SHOWWINDOW | NativeFunctions.SWP_NOACTIVATE | NativeFunctions.SWP_NOMOVE | NativeFunctions.SWP_NOSIZE);
|
|
}
|
|
|
|
if(ShouldAnimate())
|
|
{
|
|
try
|
|
{
|
|
m_AnimationInProgress=true;
|
|
BarFunctions.AnimateControl(this,true,m_AlertAnimationDuration,rStart,rEnd);
|
|
}
|
|
finally
|
|
{
|
|
m_AnimationInProgress=false;
|
|
}
|
|
}
|
|
else
|
|
base.Show();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays balloon.
|
|
/// </summary>
|
|
public new void Show()
|
|
{
|
|
this.Show(true);
|
|
}
|
|
/// <summary>
|
|
/// Called when balloon is hidden.
|
|
/// </summary>
|
|
protected virtual void HideBalloon()
|
|
{
|
|
DestroyAutoCloseTimer();
|
|
if (ShouldAnimate())
|
|
{
|
|
Rectangle rStart = new Rectangle(this.Location, this.Size);
|
|
Rectangle rEnd = GetAnimationRectangle();
|
|
try
|
|
{
|
|
m_AnimationInProgress = true;
|
|
BarFunctions.AnimateControl(this, false, m_AlertAnimationDuration, rStart, rEnd);
|
|
}
|
|
finally
|
|
{
|
|
m_AnimationInProgress = false;
|
|
}
|
|
}
|
|
else
|
|
base.Hide();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hides balloon.
|
|
/// </summary>
|
|
public new void Hide()
|
|
{
|
|
HideBalloon();
|
|
}
|
|
|
|
private bool ShouldAnimate()
|
|
{
|
|
if (m_Style != eBallonStyle.Balloon && m_AlertAnimation != eAlertAnimation.None && !this.DesignMode)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
private Rectangle GetAnimationRectangle()
|
|
{
|
|
Rectangle r=new Rectangle(this.Location,this.Size);
|
|
if(m_AlertAnimation==eAlertAnimation.BottomToTop)// && bShowing || m_AlertAnimation==eAlertAnimation.TopToBottom && !bShowing)
|
|
{
|
|
r.Y=r.Bottom-1;
|
|
r.Height=1;
|
|
}
|
|
else if(m_AlertAnimation==eAlertAnimation.TopToBottom)
|
|
{
|
|
r.Height=1;
|
|
}
|
|
else if(m_AlertAnimation==eAlertAnimation.LeftToRight)
|
|
{
|
|
r.Width=2;
|
|
}
|
|
else if(m_AlertAnimation==eAlertAnimation.RightToLeft)
|
|
{
|
|
r.X=r.Right-1;
|
|
r.Width=1;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets/Sets whether Balloon is visible.
|
|
/// </summary>
|
|
[DevCoBrowsable(true)]
|
|
public new bool Visible
|
|
{
|
|
get { return base.Visible;}
|
|
set
|
|
{
|
|
if(value)
|
|
this.Show();
|
|
else
|
|
this.Hide();
|
|
}
|
|
}
|
|
|
|
const int WM_MOUSEACTIVATE = 0x21;
|
|
const int MA_NOACTIVATE = 3;
|
|
protected override void WndProc(ref Message m)
|
|
{
|
|
if(m.Msg==WM_MOUSEACTIVATE)
|
|
{
|
|
m.Result=new System.IntPtr(MA_NOACTIVATE);
|
|
return;
|
|
}
|
|
base.WndProc(ref m);
|
|
}
|
|
|
|
private class ImageButton
|
|
{
|
|
private Rectangle m_Bounds=Rectangle.Empty;
|
|
private Control m_Parent=null;
|
|
private bool m_MouseOver=false;
|
|
private bool m_MouseDown=false;
|
|
public Image Normal=null;
|
|
public Image Hover=null;
|
|
public Image Pressed=null;
|
|
|
|
public event EventHandler Click;
|
|
|
|
public ImageButton(Control parent, Rectangle bounds)
|
|
{
|
|
m_Parent=parent;
|
|
m_Bounds=bounds;
|
|
}
|
|
|
|
public virtual void Paint(Graphics g)
|
|
{
|
|
Rectangle bounds = m_Bounds;
|
|
if(m_MouseDown)
|
|
{
|
|
if(Pressed!=null)
|
|
g.DrawImage(Pressed,bounds);
|
|
}
|
|
else if(m_MouseOver)
|
|
{
|
|
if(Hover!=null)
|
|
g.DrawImage(Hover,bounds);
|
|
}
|
|
else
|
|
{
|
|
if(Normal!=null)
|
|
g.DrawImage(Normal,bounds);
|
|
}
|
|
}
|
|
|
|
public virtual void OnMouseMove(MouseEventArgs e)
|
|
{
|
|
if(m_MouseDown)
|
|
return;
|
|
|
|
if(m_Bounds.Contains(e.X,e.Y))
|
|
{
|
|
if(!m_MouseOver)
|
|
{
|
|
m_MouseOver=true;
|
|
if(m_Parent!=null)
|
|
m_Parent.Invalidate(m_Bounds);
|
|
}
|
|
}
|
|
else if(m_MouseOver)
|
|
{
|
|
m_MouseOver=false;
|
|
if(m_Parent!=null)
|
|
m_Parent.Invalidate(m_Bounds);
|
|
}
|
|
}
|
|
public virtual void OnMouseDown(MouseEventArgs e)
|
|
{
|
|
if(m_Bounds.Contains(e.X,e.Y) && !m_MouseDown)
|
|
{
|
|
m_MouseDown=true;
|
|
if(m_Parent!=null)
|
|
m_Parent.Invalidate(m_Bounds);
|
|
}
|
|
}
|
|
|
|
public virtual void OnMouseUp(MouseEventArgs e)
|
|
{
|
|
if(m_Bounds.Contains(e.X,e.Y) && m_MouseDown)
|
|
{
|
|
m_MouseDown=false;
|
|
if(m_Parent!=null)
|
|
m_Parent.Invalidate(m_Bounds);
|
|
if(Click!=null)
|
|
Click(this,new EventArgs());
|
|
}
|
|
else if(m_MouseOver || m_MouseDown)
|
|
{
|
|
m_MouseDown=false;
|
|
m_MouseOver=false;
|
|
if(m_Parent!=null)
|
|
m_Parent.Invalidate(m_Bounds);
|
|
}
|
|
}
|
|
|
|
public virtual void OnMouseLeave(EventArgs e)
|
|
{
|
|
if(m_MouseOver && !m_MouseDown)
|
|
{
|
|
m_MouseOver=false;
|
|
if(m_Parent!=null)
|
|
m_Parent.Invalidate(m_Bounds);
|
|
}
|
|
}
|
|
|
|
public bool MouseDown
|
|
{
|
|
get {return m_MouseDown;}
|
|
}
|
|
|
|
public bool MouseOver
|
|
{
|
|
get {return m_MouseOver;}
|
|
}
|
|
|
|
public Rectangle Bounds
|
|
{
|
|
get {return m_Bounds;}
|
|
set {m_Bounds=value;}
|
|
}
|
|
|
|
public Point Location
|
|
{
|
|
get {return m_Bounds.Location;}
|
|
set {m_Bounds.Location=value;}
|
|
}
|
|
|
|
public System.Drawing.Size Size
|
|
{
|
|
get {return m_Bounds.Size;}
|
|
set {m_Bounds.Size=value;}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class CustomPaintEventArgs:EventArgs
|
|
{
|
|
private System.Drawing.Graphics m_Graphics=null;
|
|
private Rectangle m_PaintRectangle=Rectangle.Empty;
|
|
public CustomPaintEventArgs(Graphics g, Rectangle r)
|
|
{
|
|
m_Graphics=g;
|
|
m_PaintRectangle=r;
|
|
}
|
|
|
|
public System.Drawing.Graphics Graphics
|
|
{
|
|
get {return m_Graphics;}
|
|
}
|
|
|
|
public Rectangle PaintRectangle
|
|
{
|
|
get {return m_PaintRectangle;}
|
|
}
|
|
}
|
|
}
|