// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// Copyright (c) 2005 Novell, Inc. (http://www.novell.com)
//
// Authors:
// Jackson Harper (jackson@ximian.com)
//
//
using System;
using System.Drawing;
using System.Runtime.InteropServices;
namespace System.Windows.Forms{
internal abstract class InternalWindowManager {
private TitleButtons title_buttons;
internal Form form;
// moving windows
internal Point start;
internal State state;
protected Point clicked_point;
private FormPos sizing_edge;
internal Rectangle virtual_position;
private Rectangle normal_bounds;
private Rectangle iconic_bounds;
public enum State {
Idle,
Moving,
Sizing,
}
[Flags]
public enum FormPos {
None,
TitleBar = 1,
Top = 2,
Left = 4,
Right = 8,
Bottom = 16,
TopLeft = Top | Left,
TopRight = Top | Right,
BottomLeft = Bottom | Left,
BottomRight = Bottom | Right,
AnyEdge = Top | Left | Right | Bottom,
}
public InternalWindowManager (Form form)
{
this.form = form;
form.SizeChanged += new EventHandler (FormSizeChangedHandler);
title_buttons = new TitleButtons (form);
ThemeEngine.Current.ManagedWindowSetButtonLocations (this);
}
public Form Form {
get { return form; }
}
public int IconWidth {
get { return TitleBarHeight - 5; }
}
public TitleButtons TitleButtons {
get {
return title_buttons;
}
}
internal Rectangle NormalBounds {
get {
return normal_bounds;
}
set {
normal_bounds = value;
}
}
internal Size IconicSize {
get {
return SystemInformation.MinimizedWindowSize;
}
}
internal Rectangle IconicBounds {
get {
if (iconic_bounds == Rectangle.Empty)
return Rectangle.Empty;
Rectangle result = iconic_bounds;
result.Y = Form.Parent.ClientRectangle.Bottom - iconic_bounds.Y;
return result;
}
set {
iconic_bounds = value;
iconic_bounds.Y = Form.Parent.ClientRectangle.Bottom - iconic_bounds.Y;
}
}
internal virtual Rectangle MaximizedBounds {
get {
return Form.Parent.ClientRectangle;
}
}
public virtual void UpdateWindowState (FormWindowState old_window_state, FormWindowState new_window_state, bool force)
{
if (old_window_state == FormWindowState.Normal) {
NormalBounds = form.Bounds;
} else if (old_window_state == FormWindowState.Minimized) {
IconicBounds = form.Bounds;
}
switch (new_window_state) {
case FormWindowState.Minimized:
if (IconicBounds == Rectangle.Empty) {
Size size = IconicSize;
Point location = new Point (0, Form.Parent.ClientSize.Height - size.Height);
IconicBounds = new Rectangle (location, size);
}
form.Bounds = IconicBounds;
break;
case FormWindowState.Maximized:
form.Bounds = MaximizedBounds;
break;
case FormWindowState.Normal:
form.Bounds = NormalBounds;
break;
}
UpdateWindowDecorations (new_window_state);
form.ResetCursor ();
}
public virtual void UpdateWindowDecorations (FormWindowState window_state)
{
ThemeEngine.Current.ManagedWindowSetButtonLocations (this);
if (form.IsHandleCreated)
XplatUI.RequestNCRecalc (form.Handle);
}
public virtual bool WndProc (ref Message m)
{
#if debug
Console.WriteLine(DateTime.Now.ToLongTimeString () + " " + this.GetType () .Name + " (Handle={0},Text={1}) received message {2}", form.IsHandleCreated ? form.Handle : IntPtr.Zero, form.Text, m.ToString ());
#endif
switch ((Msg)m.Msg) {
// The mouse handling messages are actually
// not WM_NC* messages except for the first button and NCMOVEs
// down because we capture on the form
case Msg.WM_MOUSEMOVE:
return HandleMouseMove (form, ref m);
case Msg.WM_LBUTTONUP:
HandleLButtonUp (ref m);
break;
case Msg.WM_RBUTTONDOWN:
return HandleRButtonDown (ref m);
case Msg.WM_LBUTTONDOWN:
return HandleLButtonDown (ref m);
case Msg.WM_LBUTTONDBLCLK:
return HandleLButtonDblClick (ref m);
case Msg.WM_PARENTNOTIFY:
if (Control.LowOrder(m.WParam.ToInt32()) == (int) Msg.WM_LBUTTONDOWN)
Activate ();
break;
case Msg.WM_NCHITTEST:
return HandleNCHitTest (ref m);
// Return true from these guys, otherwise win32 will mess up z-order
case Msg.WM_NCLBUTTONUP:
HandleNCLButtonUp (ref m);
return true;
case Msg.WM_NCLBUTTONDOWN:
HandleNCLButtonDown (ref m);
return true;
case Msg.WM_NCMOUSEMOVE:
HandleNCMouseMove (ref m);
return true;
case Msg.WM_NCLBUTTONDBLCLK:
HandleNCLButtonDblClick (ref m);
break;
case Msg.WM_NCMOUSELEAVE:
HandleNCMouseLeave (ref m);
break;
case Msg.WM_MOUSELEAVE:
HandleMouseLeave (ref m);
break;
case Msg.WM_NCCALCSIZE:
return HandleNCCalcSize (ref m);
case Msg.WM_NCPAINT:
return HandleNCPaint (ref m);
}
return false;
}
protected virtual bool HandleNCPaint (ref Message m)
{
PaintEventArgs pe = XplatUI.PaintEventStart (ref m, form.Handle, false);
Rectangle clip;
if (form.ActiveMenu != null) {
Point pnt;
pnt = GetMenuOrigin ();
// The entire menu has to be in the clip rectangle because the
// control buttons are right-aligned and otherwise they would
// stay painted when the window gets resized.
clip = new Rectangle (pnt.X, pnt.Y, form.ClientSize.Width, 0);
clip = Rectangle.Union (clip, pe.ClipRectangle);
pe.SetClip (clip);
pe.Graphics.SetClip (clip);
form.ActiveMenu.Draw (pe, new Rectangle (pnt.X, pnt.Y, form.ClientSize.Width, 0));
}
if (HasBorders || IsMinimized && !(Form.IsMdiChild && IsMaximized)) {
// clip region is not correct on win32.
// use the entire form's area.
clip = new Rectangle (0, 0, form.Width, form.Height);
ThemeEngine.Current.DrawManagedWindowDecorations (pe.Graphics, clip, this);
}
XplatUI.PaintEventEnd (ref m, form.Handle, false);
return true;
}
protected virtual bool HandleNCCalcSize (ref Message m)
{
XplatUIWin32.NCCALCSIZE_PARAMS ncp;
XplatUIWin32.RECT rect;
if (m.WParam == (IntPtr)1) {
ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure (m.LParam,
typeof (XplatUIWin32.NCCALCSIZE_PARAMS));
ncp.rgrc1 = NCCalcSize (ncp.rgrc1);
Marshal.StructureToPtr (ncp, m.LParam, true);
} else {
rect = (XplatUIWin32.RECT) Marshal.PtrToStructure (m.LParam, typeof (XplatUIWin32.RECT));
rect = NCCalcSize (rect);
Marshal.StructureToPtr (rect, m.LParam, true);
}
return true;
}
protected virtual XplatUIWin32.RECT NCCalcSize (XplatUIWin32.RECT proposed_window_rect)
{
int bw = ThemeEngine.Current.ManagedWindowBorderWidth (this);
if (HasBorders) {
proposed_window_rect.top += TitleBarHeight + bw;
proposed_window_rect.bottom -= bw;
proposed_window_rect.left += bw;
proposed_window_rect.right -= bw;
}
if (XplatUI.RequiresPositiveClientAreaSize) {
// This is necessary for Linux, can't handle <= 0-sized
// client areas correctly.
if (proposed_window_rect.right <= proposed_window_rect.left) {
proposed_window_rect.right += proposed_window_rect.left - proposed_window_rect.right + 1;
}
if (proposed_window_rect.top >= proposed_window_rect.bottom) {
proposed_window_rect.bottom += proposed_window_rect.top - proposed_window_rect.bottom + 1;
}
}
return proposed_window_rect;
}
protected virtual bool HandleNCHitTest (ref Message m)
{
int x = Control.LowOrder ((int)m.LParam.ToInt32 ());
int y = Control.HighOrder ((int)m.LParam.ToInt32 ());
NCPointToClient (ref x, ref y);
FormPos pos = FormPosForCoords (x, y);
if (pos == FormPos.TitleBar) {
m.Result = new IntPtr ((int)HitTest.HTCAPTION);
return true;
}
if (!IsSizable)
return false;
switch (pos) {
case FormPos.Top:
m.Result = new IntPtr ((int)HitTest.HTTOP);
break;
case FormPos.Left:
m.Result = new IntPtr ((int)HitTest.HTLEFT);
break;
case FormPos.Right:
m.Result = new IntPtr ((int)HitTest.HTRIGHT);
break;
case FormPos.Bottom:
m.Result = new IntPtr ((int)HitTest.HTBOTTOM);
break;
case FormPos.TopLeft:
m.Result = new IntPtr ((int)HitTest.HTTOPLEFT);
break;
case FormPos.TopRight:
m.Result = new IntPtr ((int)HitTest.HTTOPRIGHT);
break;
case FormPos.BottomLeft:
m.Result = new IntPtr ((int)HitTest.HTBOTTOMLEFT);
break;
case FormPos.BottomRight:
m.Result = new IntPtr ((int)HitTest.HTBOTTOMRIGHT);
break;
default:
// We return false so that DefWndProc handles things
return false;
}
return true;
}
public virtual void UpdateBorderStyle (FormBorderStyle border_style)
{
if (form.IsHandleCreated) {
XplatUI.SetBorderStyle (form.Handle, border_style);
}
if (ShouldRemoveWindowManager (border_style)) {
form.RemoveWindowManager ();
return;
}
ThemeEngine.Current.ManagedWindowSetButtonLocations (this);
}
public virtual void SetWindowState (FormWindowState old_state, FormWindowState window_state)
{
UpdateWindowState (old_state, window_state, false);
}
public virtual FormWindowState GetWindowState ()
{
return form.window_state;
}
public virtual void PointToClient (ref int x, ref int y)
{
// toolwindows stay in screencoords we just have to make sure
// they obey the working area
Rectangle working = SystemInformation.WorkingArea;
if (x > working.Right)
x = working.Right;
if (x < working.Left)
x = working.Left;
if (y < working.Top)
y = working.Top;
if (y > working.Bottom)
y = working.Bottom;
}
public virtual void PointToScreen (ref int x, ref int y)
{
XplatUI.ClientToScreen (form.Handle, ref x, ref y);
}
protected virtual bool ShouldRemoveWindowManager (FormBorderStyle style)
{
return style != FormBorderStyle.FixedToolWindow && style != FormBorderStyle.SizableToolWindow;
}
public bool IconRectangleContains (int x, int y)
{
if (!ShowIcon)
return false;
Rectangle icon = ThemeEngine.Current.ManagedWindowGetTitleBarIconArea (this);
return icon.Contains (x, y);
}
public bool ShowIcon {
get {
#if NET_2_0
if (!Form.ShowIcon)
return false;
#endif
if (!HasBorders)
return false;
if (IsMinimized)
return true;
if (IsToolWindow || Form.FormBorderStyle == FormBorderStyle.FixedDialog)
return false;
return true;
}
}
protected virtual void Activate ()
{
form.Invalidate (true);
form.Update ();
}
public virtual bool IsActive {
get {
return true;
}
}
private void FormSizeChangedHandler (object sender, EventArgs e)
{
if (form.IsHandleCreated) {
ThemeEngine.Current.ManagedWindowSetButtonLocations (this);
XplatUI.InvalidateNC (form.Handle);
}
}
protected virtual bool HandleRButtonDown (ref Message m)
{
Activate ();
return false;
}
protected virtual bool HandleLButtonDown (ref Message m)
{
Activate ();
return false;
}
protected virtual bool HandleLButtonDblClick(ref Message m)
{
return false;
}
protected virtual bool HandleNCMouseLeave (ref Message m)
{
int x = Control.LowOrder ((int)m.LParam.ToInt32 ());
int y = Control.HighOrder ((int)m.LParam.ToInt32 ());
NCPointToClient (ref x, ref y);
FormPos pos = FormPosForCoords (x, y);
if (pos != FormPos.TitleBar) {
HandleTitleBarLeave (x, y);
return true;
}
return true;
}
protected virtual bool HandleNCMouseMove (ref Message m)
{
int x = Control.LowOrder((int)m.LParam.ToInt32( ));
int y = Control.HighOrder((int)m.LParam.ToInt32( ));
NCPointToClient (ref x, ref y);
FormPos pos = FormPosForCoords (x, y);
if (pos == FormPos.TitleBar) {
HandleTitleBarMouseMove (x, y);
return true;
}
if (form.ActiveMenu != null && XplatUI.IsEnabled (form.Handle)) {
MouseEventArgs mea = new MouseEventArgs (Form.FromParamToMouseButtons (m.WParam.ToInt32 ()), form.mouse_clicks, x, y, 0);
form.ActiveMenu.OnMouseMove (form, mea);
}
return true;
}
protected virtual bool HandleNCLButtonDown (ref Message m)
{
Activate ();
start = Cursor.Position;
virtual_position = form.Bounds;
int x = Control.LowOrder ((int) m.LParam.ToInt32 ());
int y = Control.HighOrder ((int) m.LParam.ToInt32 ());
// Need to adjust because we are in NC land
NCPointToClient (ref x, ref y);
FormPos pos = FormPosForCoords (x, y);
if (form.ActiveMenu != null && XplatUI.IsEnabled (form.Handle)) {
MouseEventArgs mea = new MouseEventArgs (Form.FromParamToMouseButtons (m.WParam.ToInt32 ()), form.mouse_clicks, x, y - TitleBarHeight, 0);
form.ActiveMenu.OnMouseDown (form, mea);
}
if (pos == FormPos.TitleBar) {
HandleTitleBarDown (x, y);
return true;
}
if (IsSizable) {
if ((pos & FormPos.AnyEdge) == 0)
return false;
virtual_position = form.Bounds;
state = State.Sizing;
sizing_edge = pos;
form.Capture = true;
return true;
}
return false;
}
protected virtual void HandleNCLButtonDblClick (ref Message m)
{
int x = Control.LowOrder ((int)m.LParam.ToInt32 ());
int y = Control.HighOrder ((int)m.LParam.ToInt32 ());
// Need to adjust because we are in NC land
NCPointToClient (ref x, ref y);
FormPos pos = FormPosForCoords (x, y);
if (pos == FormPos.TitleBar || pos == FormPos.Top)
HandleTitleBarDoubleClick (x, y);
}
protected virtual void HandleTitleBarDoubleClick (int x, int y)
{
}
protected virtual void HandleTitleBarLeave (int x, int y)
{
title_buttons.MouseLeave (x, y);
}
protected virtual void HandleTitleBarMouseMove (int x, int y)
{
if (title_buttons.MouseMove (x, y))
XplatUI.InvalidateNC (form.Handle);
}
protected virtual void HandleTitleBarUp (int x, int y)
{
title_buttons.MouseUp (x, y);
return;
}
protected virtual void HandleTitleBarDown (int x, int y)
{
title_buttons.MouseDown (x, y);
if (!TitleButtons.AnyPushedTitleButtons && !IsMaximized) {
state = State.Moving;
clicked_point = new Point (x, y);
if (form.Parent != null) {
form.CaptureWithConfine (form.Parent);
} else {
form.Capture = true;
}
}
XplatUI.InvalidateNC (form.Handle);
}
private bool HandleMouseMove (Form form, ref Message m)
{
switch (state) {
case State.Moving:
HandleWindowMove (m);
return true;
case State.Sizing:
HandleSizing (m);
return true;
}
return false;
}
private void HandleMouseLeave (ref Message m)
{
form.ResetCursor ();
}
protected virtual void HandleWindowMove (Message m)
{
Point move = MouseMove (Cursor.Position);
UpdateVP (virtual_position.X + move.X, virtual_position.Y + move.Y,
virtual_position.Width, virtual_position.Height);
}
private void HandleSizing (Message m)
{
Rectangle pos = virtual_position;
int mw;
int mh;
if (IsToolWindow) {
int border_width = BorderWidth;
mw = 2 * (border_width + Theme.ManagedWindowSpacingAfterLastTitleButton) + ThemeEngine.Current.ManagedWindowButtonSize (this).Width;
mh = 2 * border_width + TitleBarHeight;
} else {
Size minimum_size = SystemInformation.MinWindowTrackSize;
mw = minimum_size.Width;
mh = minimum_size.Height;
}
int x = Cursor.Position.X;
int y = Cursor.Position.Y;
PointToClient (ref x, ref y);
if ((sizing_edge & FormPos.Top) != 0) {
if (pos.Bottom - y < mh)
y = pos.Bottom - mh;
pos.Height = pos.Bottom - y;
pos.Y = y;
} else if ((sizing_edge & FormPos.Bottom) != 0) {
int height = y - pos.Top;
if (height <= mh)
height = mh;
pos.Height = height;
}
if ((sizing_edge & FormPos.Left) != 0) {
if (pos.Right - x < mw)
x = pos.Right - mw;
pos.Width = pos.Right - x;
pos.X = x;
} else if ((sizing_edge & FormPos.Right) != 0) {
int width = x - form.Left;
if (width <= mw)
width = mw;
pos.Width = width;
}
UpdateVP (pos);
}
public bool IsMaximized {
get { return GetWindowState () == FormWindowState.Maximized; }
}
public bool IsMinimized {
get { return GetWindowState () == FormWindowState.Minimized; }
}
public bool IsSizable {
get {
switch (form.FormBorderStyle) {
case FormBorderStyle.Sizable:
case FormBorderStyle.SizableToolWindow:
return (form.window_state != FormWindowState.Minimized);
default:
return false;
}
}
}
public bool HasBorders {
get {
return form.FormBorderStyle != FormBorderStyle.None;
}
}
public bool IsToolWindow {
get {
if (form.FormBorderStyle == FormBorderStyle.SizableToolWindow ||
form.FormBorderStyle == FormBorderStyle.FixedToolWindow ||
form.GetCreateParams().IsSet (WindowExStyles.WS_EX_TOOLWINDOW))
return true;
return false;
}
}
public int TitleBarHeight {
get {
return ThemeEngine.Current.ManagedWindowTitleBarHeight (this);
}
}
public int BorderWidth {
get {
return ThemeEngine.Current.ManagedWindowBorderWidth (this);
}
}
public virtual int MenuHeight {
get {
return (form.Menu != null ? ThemeEngine.Current.MenuHeight : 0);
}
}
protected void UpdateVP (Rectangle r)
{
UpdateVP (r.X, r.Y, r.Width, r.Height);
}
protected void UpdateVP (Point loc, int w, int h)
{
UpdateVP (loc.X, loc.Y, w, h);
}
protected void UpdateVP (int x, int y, int w, int h)
{
virtual_position.X = x;
virtual_position.Y = y;
virtual_position.Width = w;
virtual_position.Height = h;
DrawVirtualPosition (virtual_position);
}
protected virtual void HandleLButtonUp (ref Message m)
{
if (state == State.Idle)
return;
ClearVirtualPosition ();
form.Capture = false;
if (state == State.Moving && form.Location != virtual_position.Location)
form.Location = virtual_position.Location;
else if (state == State.Sizing && form.Bounds != virtual_position)
form.Bounds = virtual_position;
state = State.Idle;
OnWindowFinishedMoving ();
}
private bool HandleNCLButtonUp (ref Message m)
{
if (form.Capture) {
ClearVirtualPosition ();
form.Capture = false;
state = State.Idle;
if (form.MdiContainer != null)
form.MdiContainer.SizeScrollBars();
}
int x = Control.LowOrder ((int) m.LParam.ToInt32 ());
int y = Control.HighOrder ((int) m.LParam.ToInt32 ());
NCPointToClient (ref x, ref y);
FormPos pos = FormPosForCoords (x, y);
if (pos == FormPos.TitleBar) {
HandleTitleBarUp (x, y);
return true;
}
return true;
}
protected void DrawTitleButton (Graphics dc, TitleButton button, Rectangle clip)
{
if (!button.Rectangle.IntersectsWith (clip))
return;
ThemeEngine.Current.ManagedWindowDrawMenuButton (dc, button, clip, this);
}
public virtual void DrawMaximizedButtons (object sender, PaintEventArgs pe)
{
}
protected Point MouseMove (Point pos)
{
return new Point (pos.X - start.X, pos.Y - start.Y);
}
protected virtual void DrawVirtualPosition (Rectangle virtual_position)
{
form.Bounds = virtual_position;
start = Cursor.Position;
}
protected virtual void ClearVirtualPosition ()
{
}
protected virtual void OnWindowFinishedMoving ()
{
}
protected virtual void NCPointToClient(ref int x, ref int y) {
form.PointToClient(ref x, ref y);
NCClientToNC (ref x, ref y);
}
protected virtual void NCClientToNC (ref int x, ref int y) {
y += TitleBarHeight;
y += BorderWidth;
y += MenuHeight;
}
internal Point GetMenuOrigin ()
{
return new Point (BorderWidth, BorderWidth + TitleBarHeight);
}
protected FormPos FormPosForCoords (int x, int y)
{
int bw = BorderWidth;
if (y < TitleBarHeight + bw) {
// Console.WriteLine ("A");
if (y > bw && x > bw &&
x < form.Width - bw)
return FormPos.TitleBar;
if (x < bw || (x < 20 && y < bw))
return FormPos.TopLeft;
if (x > form.Width - bw ||
(x > form.Width - 20 && y < bw))
return FormPos.TopRight;
if (y < bw)
return FormPos.Top;
} else if (y > form.Height - 20) {
// Console.WriteLine ("B");
if (x < bw ||
(x < 20 && y > form.Height - bw))
return FormPos.BottomLeft;
if (x > form.Width - (bw * 2) ||
(x > form.Width - 20 &&
y > form.Height - bw))
return FormPos.BottomRight;
if (y > form.Height - (bw * 2))
return FormPos.Bottom;
} else if (x < bw) {
// Console.WriteLine ("C");
return FormPos.Left;
} else if (x > form.Width - (bw * 2)) {
// Console.WriteLine ("D");
return FormPos.Right;
} else {
// Console.WriteLine ("E {0}", form.Width - bw);
}
return FormPos.None;
}
}
internal class TitleButton
{
public Rectangle Rectangle;
public ButtonState State;
public CaptionButton Caption;
private EventHandler Clicked;
public bool Visible;
bool entered;
public TitleButton (CaptionButton caption, EventHandler clicked)
{
Caption = caption;
Clicked = clicked;
}
public void OnClick ()
{
if (Clicked != null) {
Clicked (this, EventArgs.Empty);
}
}
public bool Entered {
get { return entered; }
set { entered = value; }
}
}
internal class TitleButtons : System.Collections.IEnumerable
{
public TitleButton MinimizeButton;
public TitleButton MaximizeButton;
public TitleButton RestoreButton;
public TitleButton CloseButton;
public TitleButton HelpButton;
public TitleButton [] AllButtons;
public bool Visible;
private ToolTip.ToolTipWindow tooltip;
private Timer tooltip_timer;
private TitleButton tooltip_hovered_button;
private TitleButton tooltip_hidden_button;
private const int tooltip_hide_interval = 3000;
private const int tooltip_show_interval = 1000;
private Form form;
public TitleButtons (Form frm)
{
this.form = frm;
this.Visible = true;
MinimizeButton = new TitleButton (CaptionButton.Minimize, new EventHandler (ClickHandler));
MaximizeButton = new TitleButton (CaptionButton.Maximize, new EventHandler (ClickHandler));
RestoreButton = new TitleButton (CaptionButton.Restore, new EventHandler (ClickHandler));
CloseButton = new TitleButton (CaptionButton.Close, new EventHandler (ClickHandler));
HelpButton = new TitleButton (CaptionButton.Help, new EventHandler (ClickHandler));
AllButtons = new TitleButton [] { MinimizeButton, MaximizeButton, RestoreButton, CloseButton, HelpButton };
}
private void ClickHandler (object sender, EventArgs e)
{
if (!Visible) {
return;
}
TitleButton button = (TitleButton) sender;
switch (button.Caption) {
case CaptionButton.Close:
form.Close ();
break;
case CaptionButton.Help:
Console.WriteLine ("Help not implemented.");
break;
case CaptionButton.Maximize:
form.WindowState = FormWindowState.Maximized;
break;
case CaptionButton.Minimize:
form.WindowState = FormWindowState.Minimized;
break;
case CaptionButton.Restore:
form.WindowState = FormWindowState.Normal;
break;
}
}
public TitleButton FindButton (int x, int y)
{
if (!Visible) {
return null;
}
foreach (TitleButton button in AllButtons) {
if (button.Visible && button.Rectangle.Contains (x, y)) {
return button;
}
}
return null;
}
public bool AnyPushedTitleButtons {
get {
if (!Visible) {
return false;
}
foreach (TitleButton button in AllButtons) {
if (button.Visible && button.State == ButtonState.Pushed) {
return true;
}
}
return false;
}
}
#region IEnumerable Members
public System.Collections.IEnumerator GetEnumerator ()
{
return AllButtons.GetEnumerator ();
}
#endregion
#region ToolTip helpers
// Called from MouseMove if mouse is over a button
public void ToolTipStart (TitleButton button)
{
tooltip_hovered_button = button;
if (tooltip_hovered_button == tooltip_hidden_button)
return;
tooltip_hidden_button = null;
if (tooltip != null && tooltip.Visible)
ToolTipShow (true);
if (tooltip_timer == null) {
tooltip_timer = new Timer ();
tooltip_timer.Tick += new EventHandler (ToolTipTimerTick);
}
tooltip_timer.Interval = tooltip_show_interval;
tooltip_timer.Start ();
tooltip_hovered_button = button;
}
public void ToolTipTimerTick (object sender, EventArgs e)
{
if (tooltip_timer.Interval == tooltip_hide_interval) {
tooltip_hidden_button = tooltip_hovered_button;
ToolTipHide (false);
} else {
ToolTipShow (false);
}
}
// Called from timer (with only_refresh = false)
// Called from ToolTipStart if tooltip is already shown (with only_refresh = true)
public void ToolTipShow (bool only_refresh)
{
if (!form.Visible)
return;
string text = Locale.GetText (tooltip_hovered_button.Caption.ToString ());
tooltip_timer.Interval = tooltip_hide_interval;
tooltip_timer.Enabled = true;
if (only_refresh && (tooltip == null || !tooltip.Visible)) {
return;
}
if (tooltip == null)
tooltip = new ToolTip.ToolTipWindow ();
else if (tooltip.Text == text && tooltip.Visible)
return;
else if (tooltip.Visible)
tooltip.Visible = false;
if (form.WindowState == FormWindowState.Maximized && form.MdiParent != null)
tooltip.Present (form.MdiParent, text);
else
tooltip.Present (form, text);
}
// Called from MouseLeave (with reset_hidden_button = true)
// Called from MouseDown (with reset_hidden_button = false)
// Called from MouseMove if mouse isn't over any button (with reset_hidden_button = false)
// Called from Timer if hiding (with reset_hidden_button = false)
public void ToolTipHide (bool reset_hidden_button)
{
if (tooltip_timer != null)
tooltip_timer.Enabled = false;
if (tooltip != null && tooltip.Visible)
tooltip.Visible = false;
if (reset_hidden_button)
tooltip_hidden_button = null;
}
#endregion
public bool MouseMove (int x, int y)
{
if (!Visible) {
return false;
}
bool any_change = false;
bool any_pushed_buttons = AnyPushedTitleButtons;
bool any_tooltip = false;
TitleButton over_button = FindButton (x, y);
foreach (TitleButton button in this) {
if (button == null)
continue;
if (button.State == ButtonState.Inactive)
continue;
if (button == over_button) {
if (any_pushed_buttons) {
any_change |= button.State != ButtonState.Pushed;
button.State = ButtonState.Pushed;
}
ToolTipStart (button);
any_tooltip = true;
if (!button.Entered) {
button.Entered = true;
if (ThemeEngine.Current.ManagedWindowTitleButtonHasHotElementStyle (button, form))
any_change = true;
}
} else {
if (any_pushed_buttons) {
any_change |= button.State != ButtonState.Normal;
button.State = ButtonState.Normal;
}
if (button.Entered) {
button.Entered = false;
if (ThemeEngine.Current.ManagedWindowTitleButtonHasHotElementStyle (button, form))
any_change = true;
}
}
}
if (!any_tooltip)
ToolTipHide (false);
return any_change;
}
public void MouseDown (int x, int y)
{
if (!Visible) {
return;
}
ToolTipHide (false);
foreach (TitleButton button in this) {
if (button != null && button.State != ButtonState.Inactive) {
button.State = ButtonState.Normal;
}
}
TitleButton clicked_button = FindButton (x, y);
if (clicked_button != null && clicked_button.State != ButtonState.Inactive) {
clicked_button.State = ButtonState.Pushed;
}
}
public void MouseUp (int x, int y)
{
if (!Visible) {
return;
}
TitleButton clicked_button = FindButton (x, y);
if (clicked_button != null && clicked_button.State != ButtonState.Inactive) {
clicked_button.OnClick ();
}
foreach (TitleButton button in this) {
if (button == null || button.State == ButtonState.Inactive)
continue;
button.State = ButtonState.Normal;
}
if (clicked_button == CloseButton && !form.closing)
XplatUI.InvalidateNC (form.Handle);
ToolTipHide (true);
}
internal void MouseLeave (int x, int y)
{
if (!Visible) {
return;
}
foreach (TitleButton button in this) {
if (button == null || button.State == ButtonState.Inactive)
continue;
button.State = ButtonState.Normal;
}
ToolTipHide (true);
}
}
}
|