/*

  This Source Code Form is subject to the terms of the Mozilla Public

  License, v. 2.0. If a copy of the MPL was not distributed with this

  file, You can obtain one at http://mozilla.org/MPL/2.0/.

  Copyright (C) 2012 Michael Möller <mmoeller@openhardwaremonitor.org>

*/

using System;

using System.ComponentModel;

using System.Drawing;

using System.Reflection;

using System.Runtime.InteropServices;

using System.Windows.Forms;

namespace SharpDisplayManager

{

	public class NotifyIconAdv : IDisposable

	{

		private NotifyIcon genericNotifyIcon;

		private NotifyIconWindowsImplementation windowsNotifyIcon;

		public NotifyIconAdv()

		{

			int p = (int)Environment.OSVersion.Platform;

			if ((p == 4) || (p == 128))

			{ // Unix

				genericNotifyIcon = new NotifyIcon();

			}

			else

			{ // Windows

				windowsNotifyIcon = new NotifyIconWindowsImplementation();

			}

		}

		public event EventHandler BalloonTipClicked

		{

			add

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.BalloonTipClicked += value;

				else

					windowsNotifyIcon.BalloonTipClicked += value;

			}

			remove

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.BalloonTipClicked -= value;

				else

					windowsNotifyIcon.BalloonTipClicked -= value;

			}

		}

		public event EventHandler BalloonTipClosed

		{

			add

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.BalloonTipClosed += value;

				else

					windowsNotifyIcon.BalloonTipClosed += value;

			}

			remove

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.BalloonTipClosed -= value;

				else

					windowsNotifyIcon.BalloonTipClosed -= value;

			}

		}

		public event EventHandler BalloonTipShown

		{

			add

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.BalloonTipShown += value;

				else

					windowsNotifyIcon.BalloonTipShown += value;

			}

			remove

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.BalloonTipShown -= value;

				else

					windowsNotifyIcon.BalloonTipShown -= value;

			}

		}

		public event EventHandler Click

		{

			add

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.Click += value;

				else

					windowsNotifyIcon.Click += value;

			}

			remove

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.Click -= value;

				else

					windowsNotifyIcon.Click -= value;

			}

		}

		public event EventHandler DoubleClick

		{

			add

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.DoubleClick += value;

				else

					windowsNotifyIcon.DoubleClick += value;

			}

			remove

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.DoubleClick -= value;

				else

					windowsNotifyIcon.DoubleClick -= value;

			}

		}

		public event MouseEventHandler MouseClick

		{

			add

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.MouseClick += value;

				else

					windowsNotifyIcon.MouseClick += value;

			}

			remove

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.MouseClick -= value;

				else

					windowsNotifyIcon.MouseClick -= value;

			}

		}

		public event MouseEventHandler MouseDoubleClick

		{

			add

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.MouseDoubleClick += value;

				else

					windowsNotifyIcon.MouseDoubleClick += value;

			}

			remove

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.MouseDoubleClick -= value;

				else

					windowsNotifyIcon.MouseDoubleClick -= value;

			}

		}

		public event MouseEventHandler MouseDown

		{

			add

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.MouseDown += value;

				else

					windowsNotifyIcon.MouseDown += value;

			}

			remove

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.MouseDown -= value;

				else

					windowsNotifyIcon.MouseDown -= value;

			}

		}

		public event MouseEventHandler MouseMove

		{

			add

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.MouseMove += value;

				else

					windowsNotifyIcon.MouseMove += value;

			}

			remove

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.MouseMove -= value;

				else

					windowsNotifyIcon.MouseMove -= value;

			}

		}

		public event MouseEventHandler MouseUp

		{

			add

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.MouseUp += value;

				else

					windowsNotifyIcon.MouseUp += value;

			}

			remove

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.MouseUp -= value;

				else

					windowsNotifyIcon.MouseUp -= value;

			}

		}

		public string BalloonTipText

		{

			get

			{

				if (genericNotifyIcon != null)

					return genericNotifyIcon.BalloonTipText;

				else

					return windowsNotifyIcon.BalloonTipText;

			}

			set

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.BalloonTipText = value;

				else

					windowsNotifyIcon.BalloonTipText = value;

			}

		}

		public ToolTipIcon BalloonTipIcon

		{

			get

			{

				if (genericNotifyIcon != null)

					return genericNotifyIcon.BalloonTipIcon;

				else

					return windowsNotifyIcon.BalloonTipIcon;

			}

			set

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.BalloonTipIcon = value;

				else

					windowsNotifyIcon.BalloonTipIcon = value;

			}

		}

		public string BalloonTipTitle

		{

			get

			{

				if (genericNotifyIcon != null)

					return genericNotifyIcon.BalloonTipTitle;

				else

					return windowsNotifyIcon.BalloonTipTitle;

			}

			set

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.BalloonTipTitle = value;

				else

					windowsNotifyIcon.BalloonTipTitle = value;

			}

		}

		public ContextMenu ContextMenu

		{

			get

			{

				if (genericNotifyIcon != null)

					return genericNotifyIcon.ContextMenu;

				else

					return windowsNotifyIcon.ContextMenu;

			}

			set

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.ContextMenu = value;

				else

					windowsNotifyIcon.ContextMenu = value;

			}

		}

		public ContextMenuStrip ContextMenuStrip

		{

			get

			{

				if (genericNotifyIcon != null)

					return genericNotifyIcon.ContextMenuStrip;

				else

					return windowsNotifyIcon.ContextMenuStrip;

			}

			set

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.ContextMenuStrip = value;

				else

					windowsNotifyIcon.ContextMenuStrip = value;

			}

		}

		public object Tag { get; set; }

		public Icon Icon

		{

			get

			{

				if (genericNotifyIcon != null)

					return genericNotifyIcon.Icon;

				else

					return windowsNotifyIcon.Icon;

			}

			set

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.Icon = value;

				else

					windowsNotifyIcon.Icon = value;

			}

		}

		public string Text

		{

			get

			{

				if (genericNotifyIcon != null)

					return genericNotifyIcon.Text;

				else

					return windowsNotifyIcon.Text;

			}

			set

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.Text = value;

				else

					windowsNotifyIcon.Text = value;

			}

		}

		public bool Visible

		{

			get

			{

				if (genericNotifyIcon != null)

					return genericNotifyIcon.Visible;

				else

					return windowsNotifyIcon.Visible;

			}

			set

			{

				if (genericNotifyIcon != null)

					genericNotifyIcon.Visible = value;

				else

					windowsNotifyIcon.Visible = value;

			}

		}

		public void Dispose()

		{

			if (genericNotifyIcon != null)

				genericNotifyIcon.Dispose();

			else

				windowsNotifyIcon.Dispose();

		}

		public void ShowBalloonTip(int timeout)

		{

			ShowBalloonTip(timeout, BalloonTipTitle, BalloonTipText, BalloonTipIcon);

		}

		public void ShowBalloonTip(int timeout, string tipTitle, string tipText,

		  ToolTipIcon tipIcon)

		{

			if (genericNotifyIcon != null)

				genericNotifyIcon.ShowBalloonTip(timeout, tipTitle, tipText, tipIcon);

			else

				windowsNotifyIcon.ShowBalloonTip(timeout, tipTitle, tipText, tipIcon);

		}

		private class NotifyIconWindowsImplementation : Component

		{

			private static int nextId = 0;

			private object syncObj = new object();

			private Icon icon;

			private string text = "";

			private int id;

			private bool created;

			private NotifyIconNativeWindow window;

			private bool doubleClickDown;

			private bool visible;

			private MethodInfo commandDispatch;

			public event EventHandler BalloonTipClicked;

			public event EventHandler BalloonTipClosed;

			public event EventHandler BalloonTipShown;

			public event EventHandler Click;

			public event EventHandler DoubleClick;

			public event MouseEventHandler MouseClick;

			public event MouseEventHandler MouseDoubleClick;

			public event MouseEventHandler MouseDown;

			public event MouseEventHandler MouseMove;

			public event MouseEventHandler MouseUp;

			public string BalloonTipText { get; set; }

			public ToolTipIcon BalloonTipIcon { get; set; }

			public string BalloonTipTitle { get; set; }

			public ContextMenu ContextMenu { get; set; }

			public ContextMenuStrip ContextMenuStrip { get; set; }

			public object Tag { get; set; }

			public Icon Icon

			{

				get

				{

					return icon;

				}

				set

				{

					if (icon != value)

					{

						icon = value;

						UpdateNotifyIcon(visible);

					}

				}

			}

			public string Text

			{

				get

				{

					return text;

				}

				set

				{

					if (value == null)

						value = "";

					if (value.Length > 63)

						throw new ArgumentOutOfRangeException();

					if (!value.Equals(text))

					{

						text = value;

						if (visible)

							UpdateNotifyIcon(visible);

					}

				}

			}

			public bool Visible

			{

				get

				{

					return visible;

				}

				set

				{

					if (visible != value)

					{

						visible = value;

						UpdateNotifyIcon(visible);

					}

				}

			}

			public NotifyIconWindowsImplementation()

			{

				BalloonTipText = "";

				BalloonTipTitle = "";

				commandDispatch = typeof(Form).Assembly.

				  GetType("System.Windows.Forms.Command").GetMethod("DispatchID",

				  BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public,

				  null, new Type[] { typeof(int) }, null);

				id = ++NotifyIconWindowsImplementation.nextId;

				window = new NotifyIconNativeWindow(this);

				UpdateNotifyIcon(visible);

			}

			protected override void Dispose(bool disposing)

			{

				if (disposing)

				{

					if (window != null)

					{

						icon = null;

						text = "";

						UpdateNotifyIcon(false);

						window.DestroyHandle();

						window = null;

						ContextMenu = null;

						ContextMenuStrip = null;

					}

				}

				else

				{

					if (window != null && window.Handle != IntPtr.Zero)

					{

						NativeMethods.PostMessage(

						  new HandleRef(window, window.Handle), WM_CLOSE, 0, 0);

						window.ReleaseHandle();

					}

				}

				base.Dispose(disposing);

			}

			public void ShowBalloonTip(int timeout)

			{

				ShowBalloonTip(timeout, BalloonTipTitle, BalloonTipText, BalloonTipIcon);

			}

			public void ShowBalloonTip(int timeout, string tipTitle, string tipText,

			  ToolTipIcon tipIcon)

			{

				if (timeout < 0)

					throw new ArgumentOutOfRangeException("timeout");

				if (string.IsNullOrEmpty(tipText))

					throw new ArgumentException("tipText");

				if (DesignMode)

					return;

				if (created)

				{

					NativeMethods.NotifyIconData data = new NativeMethods.NotifyIconData();

					if (window.Handle == IntPtr.Zero)

						window.CreateHandle(new CreateParams());

					data.Window = window.Handle;

					data.ID = id;

					data.Flags = NativeMethods.NotifyIconDataFlags.Info;

					data.TimeoutOrVersion = timeout;

					data.InfoTitle = tipTitle;

					data.Info = tipText;

					data.InfoFlags = (int)tipIcon;

					NativeMethods.Shell_NotifyIcon(

					  NativeMethods.NotifyIconMessage.Modify, data);

				}

			}

			private void ShowContextMenu()

			{

				if (ContextMenu == null && ContextMenuStrip == null)

					return;

				NativeMethods.Point p = new NativeMethods.Point();

				NativeMethods.GetCursorPos(ref p);

				NativeMethods.SetForegroundWindow(

				  new HandleRef(window, window.Handle));

				if (ContextMenu != null)

				{

					ContextMenu.GetType().InvokeMember("OnPopup",

					  BindingFlags.NonPublic | BindingFlags.InvokeMethod |

					  BindingFlags.Instance, null, ContextMenu,

					  new Object[] { System.EventArgs.Empty });

					NativeMethods.TrackPopupMenuEx(

					  new HandleRef(ContextMenu, ContextMenu.Handle), 72,

					  p.x, p.y, new HandleRef(window, window.Handle),

					  IntPtr.Zero);

					NativeMethods.PostMessage(

					  new HandleRef(window, window.Handle), WM_NULL, 0, 0);

					return;

				}

				if (ContextMenuStrip != null)

					ContextMenuStrip.GetType().InvokeMember("ShowInTaskbar",

					  BindingFlags.NonPublic | BindingFlags.InvokeMethod |

					  BindingFlags.Instance, null, ContextMenuStrip,

					  new Object[] { p.x, p.y });

			}

			private void UpdateNotifyIcon(bool showNotifyIcon)

			{

				if (DesignMode)

					return;

				lock (syncObj)

				{

					window.LockReference(showNotifyIcon);

					NativeMethods.NotifyIconData data = new NativeMethods.NotifyIconData();

					data.CallbackMessage = WM_TRAYMOUSEMESSAGE;

					data.Flags = NativeMethods.NotifyIconDataFlags.Message;

					if (showNotifyIcon && window.Handle == IntPtr.Zero)

						window.CreateHandle(new CreateParams());

					data.Window = window.Handle;

					data.ID = id;

					if (icon != null)

					{

						data.Flags |= NativeMethods.NotifyIconDataFlags.Icon;

						data.Icon = icon.Handle;

					}

					data.Flags |= NativeMethods.NotifyIconDataFlags.Tip;

					data.Tip = text;

					if (showNotifyIcon && icon != null)

					{

						if (!created)

						{

							int i = 0;

							do

							{

								created = NativeMethods.Shell_NotifyIcon(

								  NativeMethods.NotifyIconMessage.Add, data);

								if (!created)

								{

									System.Threading.Thread.Sleep(200);

									i++;

								}

							} while (!created && i < 40);

						}

						else

						{

							NativeMethods.Shell_NotifyIcon(

							  NativeMethods.NotifyIconMessage.Modify, data);

						}

					}

					else

					{

						if (created)

						{

							int i = 0;

							bool deleted = false;

							do

							{

								deleted = NativeMethods.Shell_NotifyIcon(

								  NativeMethods.NotifyIconMessage.Delete, data);

								if (!deleted)

								{

									System.Threading.Thread.Sleep(200);

									i++;

								}

							} while (!deleted && i < 40);

							created = false;

						}

					}

				}

			}

			private void ProcessMouseDown(ref Message message, MouseButtons button,

			  bool doubleClick)

			{

				if (doubleClick)

				{

					if (DoubleClick != null)

						DoubleClick(this, new MouseEventArgs(button, 2, 0, 0, 0));

					if (MouseDoubleClick != null)

						MouseDoubleClick(this, new MouseEventArgs(button, 2, 0, 0, 0));

					doubleClickDown = true;

				}

				if (MouseDown != null)

					MouseDown(this,

					  new MouseEventArgs(button, doubleClick ? 2 : 1, 0, 0, 0));

			}

			private void ProcessMouseUp(ref Message message, MouseButtons button)

			{

				if (MouseUp != null)

					MouseUp(this, new MouseEventArgs(button, 0, 0, 0, 0));

				if (!doubleClickDown)

				{

					if (Click != null)

						Click(this, new MouseEventArgs(button, 0, 0, 0, 0));

					if (MouseClick != null)

						MouseClick(this, new MouseEventArgs(button, 0, 0, 0, 0));

				}

				doubleClickDown = false;

			}

			private void ProcessInitMenuPopup(ref Message message)

			{

				if (ContextMenu != null &&

				  (bool)ContextMenu.GetType().InvokeMember("ProcessInitMenuPopup",

					BindingFlags.NonPublic | BindingFlags.InvokeMethod |

					BindingFlags.Instance, null, ContextMenu,

					new Object[] { message.WParam }))

				{

					return;

				}

				window.DefWndProc(ref message);

			}

			private void WndProc(ref Message message)

			{

				switch (message.Msg)

				{

					case WM_DESTROY:

						UpdateNotifyIcon(false);

						return;

					case WM_COMMAND:

						if (message.LParam != IntPtr.Zero)

						{

							window.DefWndProc(ref message);

							return;

						}

						commandDispatch.Invoke(null, new object[] {

            message.WParam.ToInt32() & 0xFFFF });

						return;

					case WM_INITMENUPOPUP:

						ProcessInitMenuPopup(ref message);

						return;

					case WM_TRAYMOUSEMESSAGE:

						switch ((int)message.LParam)

						{

							case WM_MOUSEMOVE:

								if (MouseMove != null)

									MouseMove(this,

									  new MouseEventArgs(Control.MouseButtons, 0, 0, 0, 0));

								return;

							case WM_LBUTTONDOWN:

								ProcessMouseDown(ref message, MouseButtons.Left, false);

								return;

							case WM_LBUTTONUP:

								ProcessMouseUp(ref message, MouseButtons.Left);

								return;

							case WM_LBUTTONDBLCLK:

								ProcessMouseDown(ref message, MouseButtons.Left, true);

								return;

							case WM_RBUTTONDOWN:

								ProcessMouseDown(ref message, MouseButtons.Right, false);

								return;

							case WM_RBUTTONUP:

								if (ContextMenu != null || ContextMenuStrip != null)

									ShowContextMenu();

								ProcessMouseUp(ref message, MouseButtons.Right);

								return;

							case WM_RBUTTONDBLCLK:

								ProcessMouseDown(ref message, MouseButtons.Right, true);

								return;

							case WM_MBUTTONDOWN:

								ProcessMouseDown(ref message, MouseButtons.Middle, false);

								return;

							case WM_MBUTTONUP:

								ProcessMouseUp(ref message, MouseButtons.Middle);

								return;

							case WM_MBUTTONDBLCLK:

								ProcessMouseDown(ref message, MouseButtons.Middle, true);

								return;

							case NIN_BALLOONSHOW:

								if (BalloonTipShown != null)

									BalloonTipShown(this, EventArgs.Empty);

								return;

							case NIN_BALLOONHIDE:

							case NIN_BALLOONTIMEOUT:

								if (BalloonTipClosed != null)

									BalloonTipClosed(this, EventArgs.Empty);

								return;

							case NIN_BALLOONUSERCLICK:

								if (BalloonTipClicked != null)

									BalloonTipClicked(this, EventArgs.Empty);

								return;

							default:

								return;

						}

				}

				if (message.Msg == NotifyIconWindowsImplementation.WM_TASKBARCREATED)

				{

					lock (syncObj)

					{

						created = false;

					}

					UpdateNotifyIcon(visible);

				}

				window.DefWndProc(ref message);

			}

			private class NotifyIconNativeWindow : NativeWindow

			{

				private NotifyIconWindowsImplementation reference;

				private GCHandle referenceHandle;

				internal NotifyIconNativeWindow(NotifyIconWindowsImplementation component)

				{

					this.reference = component;

				}

				~NotifyIconNativeWindow()

				{

					if (base.Handle != IntPtr.Zero)

						NativeMethods.PostMessage(

						  new HandleRef(this, base.Handle), WM_CLOSE, 0, 0);

				}

				public void LockReference(bool locked)

				{

					if (locked)

					{

						if (!referenceHandle.IsAllocated)

						{

							referenceHandle = GCHandle.Alloc(reference, GCHandleType.Normal);

							return;

						}

					}

					else

					{

						if (referenceHandle.IsAllocated)

							referenceHandle.Free();

					}

				}

				protected override void OnThreadException(Exception e)

				{

					Application.OnThreadException(e);

				}

				protected override void WndProc(ref Message m)

				{

					reference.WndProc(ref m);

				}

			}

			private const int WM_NULL = 0x00;

			private const int WM_DESTROY = 0x02;

			private const int WM_CLOSE = 0x10;

			private const int WM_COMMAND = 0x111;

			private const int WM_INITMENUPOPUP = 0x117;

			private const int WM_MOUSEMOVE = 0x200;

			private const int WM_LBUTTONDOWN = 0x201;

			private const int WM_LBUTTONUP = 0x202;

			private const int WM_LBUTTONDBLCLK = 0x203;

			private const int WM_RBUTTONDOWN = 0x204;

			private const int WM_RBUTTONUP = 0x205;

			private const int WM_RBUTTONDBLCLK = 0x206;

			private const int WM_MBUTTONDOWN = 0x207;

			private const int WM_MBUTTONUP = 0x208;

			private const int WM_MBUTTONDBLCLK = 0x209;

			private const int WM_TRAYMOUSEMESSAGE = 0x800;

			private const int NIN_BALLOONSHOW = 0x402;

			private const int NIN_BALLOONHIDE = 0x403;

			private const int NIN_BALLOONTIMEOUT = 0x404;

			private const int NIN_BALLOONUSERCLICK = 0x405;

			private static int WM_TASKBARCREATED =

			  NativeMethods.RegisterWindowMessage("TaskbarCreated");

			private static class NativeMethods

			{

				[DllImport("user32.dll", CharSet = CharSet.Auto)]

				public static extern IntPtr PostMessage(HandleRef hwnd, int msg,

				  int wparam, int lparam);

				[DllImport("user32.dll", CharSet = CharSet.Auto)]

				public static extern int RegisterWindowMessage(string msg);

				[Flags]

				public enum NotifyIconDataFlags : int

				{

					Message = 0x1,

					Icon = 0x2,

					Tip = 0x4,

					State = 0x8,

					Info = 0x10

				}

				[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]

				public class NotifyIconData

				{

					private int Size = Marshal.SizeOf(typeof(NotifyIconData));

					public IntPtr Window;

					public int ID;

					public NotifyIconDataFlags Flags;

					public int CallbackMessage;

					public IntPtr Icon;

					[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]

					public string Tip;

					public int State;

					public int StateMask;

					[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]

					public string Info;

					public int TimeoutOrVersion;

					[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]

					public string InfoTitle;

					public int InfoFlags;

				}

				public enum NotifyIconMessage : int

				{

					Add = 0x0,

					Modify = 0x1,

					Delete = 0x2

				}

				[DllImport("shell32.dll", CharSet = CharSet.Auto)]

				[return: MarshalAs(UnmanagedType.Bool)]

				public static extern bool Shell_NotifyIcon(NotifyIconMessage message,

				  NotifyIconData pnid);

				[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]

				public static extern bool TrackPopupMenuEx(HandleRef hmenu, int fuFlags,

				  int x, int y, HandleRef hwnd, IntPtr tpm);

				[StructLayout(LayoutKind.Sequential)]

				public struct Point

				{

					public int x;

					public int y;

				}

				[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]

				public static extern bool GetCursorPos(ref Point point);

				[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]

				public static extern bool SetForegroundWindow(HandleRef hWnd);

			}

		}

	}

}