protected override void OnRowPrePaint(DataGridViewRowPrePaintEventArgs e)
        {
            if (!e.IsLastVisibleRow)
            {
                base.OnRowPrePaint(e);
            }
            else
            {
                Rectangle rowBounds = new Rectangle(
                    this.RowHeadersWidth, e.RowBounds.Top,
                    this.Columns.GetColumnsWidth(
                    DataGridViewElementStates.Visible) -
                    this.HorizontalScrollingOffset + 1,
                    e.RowBounds.Height);

                // Paint the custom selection background.
                using (Brush backbrush = new System.Drawing.Drawing2D.LinearGradientBrush(rowBounds,
                        this.DefaultCellStyle.SelectionBackColor,
                        e.InheritedRowStyle.ForeColor,
                        System.Drawing.Drawing2D.LinearGradientMode.ForwardDiagonal))
                {
                    e.Graphics.FillRectangle(backbrush, rowBounds);
                    e.Graphics.DrawString("Das Ergebniss", this.Font, new SolidBrush(Color.Red), rowBounds.Location);
                }

                e.Handled = true;
            }
        }

using System.Windows.Forms;
using System.Security.Permissions;
using System.Drawing;
using System;

namespace DynamicControlsExample
{
	public class SpecialButton : Button
	{
		//protected override CreateParams CreateParams
		//{
		//  [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
		//  get
		//  {
		//    CreateParams createParams = new CreateParams();
		//    createParams.ClassName = NativeMethods.TOOLBARCLASSNAME;
		//    createParams.ExStyle = 0x20;
		//    createParams.Style = NativeMethods.WS_CHILD | NativeMethods.WS_VISIBLE | NativeMethods.WS_CLIPCHILDREN | NativeMethods.WS_CLIPSIBLINGS;
		//    createParams.Style = NativeMethods.CCS_NODIVIDER | NativeMethods.CCS_NORESIZE | NativeMethods.CCS_NOPARENTALIGN;
		//    createParams.Style |= NativeMethods.TBSTYLE_TOOLTIPS | NativeMethods.TBSTYLE_FLAT | NativeMethods.TBSTYLE_TRANSPARENT;
		//    createParams.Style = NativeMethods.TBSTYLE_TRANSPARENT;

		//    createParams.Style |= NativeMethods.TBSTYLE_LIST;


		//    return createParams;
		//  }
		//}

		public SpecialButton()
		{

		}

		protected override void WndProc(ref Message m)
		{
			switch (m.Msg)
			{
				case (int)NativeMethods.WM.NCPAINT:
					return;

				case (int)NativeMethods.WM.PAINT:
					this.WmPaint(ref m);
					return;
			}

			base.WndProc(ref m);
		}


		private void WmPaint(ref Message m)
		{
			IntPtr hWnd = m.HWnd;

			Rectangle rWnd = new Rectangle();
			if (NativeMethods.GetWindowRect(hWnd, ref rWnd) == 0)
				return;

			Rectangle rClip = new Rectangle(0, 0, rWnd.Width, rWnd.Height);
			IntPtr hDC = NativeMethods.GetWindowDC(hWnd);

			IntPtr hCDC = NativeMethods.CreateCompatibleDC(hDC);
			IntPtr hBitmap = NativeMethods.CreateCompatibleBitmap(hDC, rClip.Width, rClip.Height);
			NativeMethods.SelectObject(hCDC, hBitmap);
			NativeMethods.BitBlt(hCDC, 0, 0, rClip.Width, rClip.Height, hDC, 0, 0, (uint)NativeMethods.TernaryRasterOperations.SRCCOPY);

			using (Graphics g = Graphics.FromHdc(hCDC))
			{
				this.OnPaint(new PaintEventArgs(g, rClip));
			}

			NativeMethods.BitBlt(hDC, 0, 0, rClip.Width, rClip.Height, hCDC, 0, 0, (uint)NativeMethods.TernaryRasterOperations.SRCCOPY);
			NativeMethods.DeleteObject(hBitmap);
			NativeMethods.DeleteDC(hCDC);
			NativeMethods.ReleaseDC(hWnd, hDC);
		}


		protected override void OnPaint(PaintEventArgs pevent)
		{

			pevent.Graphics.DrawString(base.Text, base.Font, new SolidBrush(base.ForeColor), pevent.ClipRectangle.X, 0); 

			//base.OnPaint(pevent);
		}
	}
}

protected override CreateParams CreateParams
		{
			[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)] 
			get
			{
				CreateParams createParams = base.CreateParams;
				createParams.ClassName = NativeMethods.TOOLBARCLASSNAME;
				createParams.ExStyle = 0;
				createParams.Style = NativeMethods.WS_CHILD | NativeMethods.WS_VISIBLE | NativeMethods.WS_CLIPCHILDREN | NativeMethods.WS_CLIPSIBLINGS;
				createParams.Style |= NativeMethods.CCS_NODIVIDER | NativeMethods.CCS_NORESIZE | NativeMethods.CCS_NOPARENTALIGN;
				createParams.Style |= NativeMethods.TBSTYLE_TOOLTIPS | NativeMethods.TBSTYLE_FLAT | NativeMethods.TBSTYLE_TRANSPARENT;
				
				if (Style == CommandBarStyle.Menu)
				{
					createParams.Style |= NativeMethods.TBSTYLE_LIST;
				}

				return createParams;
			}
		}

// Eigene native windows nachricht für die commandbar auf dem die CommandControl's gezeichnet werden
		private void OnMouseMove(object sender, ADXCommandBarMultiBoxBar.CommandBarNativeMouseEventArgs e)
		{
			if (_ADXOlExplorerCommandBar.CommandBarObj is CommandBar)
			{
				CommandBar bar = _ADXOlExplorerCommandBar.CommandBarObj as CommandBar;

				if (_AdvPop.ControlObj is CommandBarPopup && _AdvBtn.ControlObj is CommandBarButton)
				{
					CommandBarPopup Pop = _AdvPop.ControlObj as CommandBarPopup;
					CommandBarButton Btn = _AdvBtn.ControlObj as CommandBarButton;
					CommandBarControl contr = bar.accHitTest(e.MouseEvent.X, e.MouseEvent.Y) as CommandBarControl;

// Tag besitzt als string eine GUID, das object selber ist kein indiez
					if (contr != null && (contr.Tag == Pop.Tag || contr.Tag == Btn.Tag))
					{
						if (!this.IsSelected)
						{
							this.IsSelected = true;
							Pop.accSelect(1, Type.Missing); // selectieren
							Btn.accSelect(1, Type.Missing); // selectieren
							Btn.State = MsoButtonState.msoButtonMixed
						}
					}
					else
						this.IsSelected = false;
				}
			}
		}

using System;
using System.ComponentModel;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using AddinExpress.MSO;
using Office;
using System.Windows.Forms;
using IApplication = Outlook.Application;
using IExplorer = Outlook.Explorer;

namespace CobraOlAddIn12
{
	[ComVisible(false)]
	[DesignTimeVisible(true)]
	[ClassInterface(ClassInterfaceType.AutoDispatch)]
	[ToolboxBitmap(typeof(Button))]
	[ToolboxItem(true)]
	public class ADXOlExplorerCommandBarEvents : ADXBaseAppEvents, ISupportInitialize
	{
		#region Declarations
		/// <summary>
		/// 
		/// </summary>
		private class CommandBarNative : NativeWindow
		{
			#region Imports
			[DllImport("User32.dll")]
			private static extern IntPtr FindWindow(string strClassName, string strWindowName);

			[DllImport("user32.dll", SetLastError = true)]
			private static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow);

			[DllImport("user32.dll")]
			private static extern bool GetWindowInfo(IntPtr hwnd, ref WINDOWINFO pwi);

			private enum MouseMessages
			{
				WM_LBUTTONDOWN = 0x0201,
				WM_LBUTTONUP = 0x202,
				WM_MBUTTONDOWN = 0x207,
				WM_MBUTTONUP = 0x208,
				WM_RBUTTONDOWN = 0x204,
				WM_RBUTTONUP = 0x205,
				WM_MOUSEMOVE = 0x200,
				WM_MOUSEWHEEL = 0x20A,
				WM_MOUSEHWHEEL = 0x20E,
			}

			private static readonly IntPtr TRUE = new IntPtr(1);
			private static readonly IntPtr FALSE = IntPtr.Zero;

			[StructLayoutAttribute(LayoutKind.Sequential)]
			private struct WINDOWINFO
			{
				/// DWORD->unsigned int
				public uint cbSize;

				/// RECT->tagRECT
				public Rectangle rcWindow;

				/// RECT->tagRECT
				public Rectangle rcClient;

				/// DWORD->unsigned int
				public uint dwStyle;

				/// DWORD->unsigned int
				public uint dwExStyle;

				/// DWORD->unsigned int
				public uint dwWindowStatus;

				/// UINT->unsigned int
				public uint cxWindowBorders;

				/// UINT->unsigned int
				public uint cyWindowBorders;

				/// ATOM->WORD->unsigned short
				public ushort atomWindowType;

				/// WORD->unsigned short
				public ushort wCreatorVersion;
			}
			#endregion

			#region Declarations
			public event EventHandler<CommandBarNativeMouseEventArgs> MouseUpEvent;
			public event EventHandler<CommandBarNativeMouseEventArgs> MouseDownEvent;
			public event EventHandler<CommandBarNativeMouseEventArgs> MouseMoveEvent;
			#endregion

			#region Properties
			/// <summary>
			/// 
			/// </summary>
			public ADXOlExplorerCommandBar CommandBar { get; private set; }
			/// <summary>
			/// 
			/// </summary>
			public IntPtr ObjHandle
			{
				get
				{
					if (this.CommandBar == null) return IntPtr.Zero;

					CommandBar cmdBar = this.CommandBar.CommandBarObj as CommandBar;

					if (cmdBar == null) return IntPtr.Zero;

					IApplication app = cmdBar.Application as IApplication;

					if (app == null) return IntPtr.Zero;

					IExplorer ex = app.Application.ActiveExplorer() as IExplorer;
					IntPtr hWnd = FindWindow("rctrl_renwnd32", ex.Caption);
					IntPtr hDocktop = FindWindowEx(hWnd, IntPtr.Zero, "MsoCommandBarDock", "MsoDockTop");
					IntPtr hCmdBar = FindWindowEx(hDocktop, IntPtr.Zero, "MsoCommandBar", cmdBar.Name);
					return hCmdBar;
				}
			}
			#endregion

			#region Constructors
			/// <summary>
			/// 
			/// </summary>
			/// <param name="cmdBar"></param>
			public CommandBarNative(ADXOlExplorerCommandBar cmdBar)
			{
				this.CommandBar = cmdBar;
			}
			#endregion

			#region Methods
			/// <summary>
			/// 
			/// </summary>
			/// <param name="m"></param>
			protected override void WndProc(ref Message m)
			{
				switch (m.Msg)
				{
					case (int)MouseMessages.WM_MBUTTONDOWN:
					case (int)MouseMessages.WM_RBUTTONDOWN:
					case (int)MouseMessages.WM_LBUTTONDOWN:
						{
							this.WmMBDown(ref m);
							if (m.Result == TRUE) return;
							break;
						}
					case (int)MouseMessages.WM_MBUTTONUP:
					case (int)MouseMessages.WM_RBUTTONUP:
					case (int)MouseMessages.WM_LBUTTONUP:
						{
							this.WmMBUp(ref m);
							if (m.Result == TRUE) return;
							break;
						}
					case (int)MouseMessages.WM_MOUSEMOVE:
						{
							this.WmMBMove(ref m);
							if (m.Result == TRUE) return;
							break;
						}
				}
				base.WndProc(ref m);
			}
			/// <summary>
			/// 
			/// </summary>
			/// <param name="m"></param>
			private void WmMBMove(ref Message m)
			{
				CommandBarNativeMouseEventArgs args = new CommandBarNativeMouseEventArgs();
				args.MouseEvent = this.CreateMouseEventArgs(m.LParam, m.Msg);

				if (this.MouseMoveEvent != null)
					this.MouseMoveEvent.Invoke(this, args);
			}
			/// <summary>
			/// 
			/// </summary>
			/// <param name="msg"></param>
			/// <returns></returns>
			private MouseButtons GetMouseButton(int msg)
			{
				switch (msg)
				{
					case (int)MouseMessages.WM_LBUTTONUP:
					case (int)MouseMessages.WM_LBUTTONDOWN:
						return MouseButtons.Left;

					case (int)MouseMessages.WM_MBUTTONUP:
					case (int)MouseMessages.WM_MBUTTONDOWN:
						return MouseButtons.Middle;

					case (int)MouseMessages.WM_RBUTTONUP:
					case (int)MouseMessages.WM_RBUTTONDOWN:
						return MouseButtons.Right;
				}
				return MouseButtons.None;
			}
			/// <summary>
			/// 
			/// </summary>
			/// <param name="m"></param>
			private void WmMBDown(ref Message m)
			{
				CommandBarNativeMouseEventArgs args = new CommandBarNativeMouseEventArgs();
				args.MouseEvent = this.CreateMouseEventArgs(m.LParam, m.Msg);

				if (this.MouseDownEvent != null)
					this.MouseDownEvent.Invoke(this, args);

				m.Result = (args.Cancel) ? TRUE : FALSE;
			}
			/// <summary>
			/// 
			/// </summary>
			/// <param name="m"></param>
			private void WmMBUp(ref Message m)
			{
				CommandBarNativeMouseEventArgs args = new CommandBarNativeMouseEventArgs();
				args.MouseEvent = this.CreateMouseEventArgs(m.LParam, m.Msg);

				if (this.MouseUpEvent != null)
					this.MouseUpEvent.Invoke(this, args);

				m.Result = (args.Cancel) ? TRUE : FALSE;
			}
			/// <summary>
			/// 
			/// </summary>
			/// <param name="lParam"></param>
			/// <param name="m"></param>
			/// <returns></returns>
			private MouseEventArgs CreateMouseEventArgs(IntPtr lParam, int m)
			{
				Point pt = new Point(lParam.ToInt32());
				Point pt2 = this.PointToCmd(pt);

				return new MouseEventArgs(this.GetMouseButton(m), 0,
					pt2.X, pt2.Y, 0);
			}
			/// <summary>
			/// 
			/// </summary>
			/// <param name="screenPoint"></param>
			/// <returns></returns>
			private Point PointToCmd(Point screenPoint)
			{
				WINDOWINFO windowInfo = new WINDOWINFO();
				GetWindowInfo(base.Handle, ref windowInfo);
				return new Point(windowInfo.rcClient.Location.X + screenPoint.X, windowInfo.rcClient.Location.Y + screenPoint.Y);
			}
			#endregion
		}
		/// <summary>
		/// 
		/// </summary>
		private class CommandBarNativeMouseEventArgs : CancelEventArgs
		{
			public MouseEventArgs MouseEvent { get; set; }
		}
		#endregion

		#region Properties
		/// <summary>
		/// 
		/// </summary>
		private Dictionary<ADXOlExplorerCommandBar, CommandBarNative> CommandBars { get; set; }
		/// <summary>
		/// 
		/// </summary>
		public override string ClassName
		{
			get
			{
				this.Bind();
				return this.GetType().ToString();
			}
		}
		#endregion

		#region Events
		[Category("Explorer")]
		[Description("Occurs before command bars events from the active explorer.")]
		public event EventHandler<CommandBarControlMouseEventArgs> MouseDown;
		[Category("Explorer")]
		[Description("Occurs before command bars events from the active explorer.")]
		public event EventHandler<CommandBarControlMouseEventArgs> MouseUp;
		[Category("Explorer")]
		[Description("Occurs before command bars events from the active explorer.")]
		public event EventHandler<CommandBarControlMouseEventArgs> MouseMove;
		#endregion

		#region Constructors
		/// <summary>
		/// 
		/// </summary>
		public ADXOlExplorerCommandBarEvents()
			: base()
		{
			this.CommandBars = new Dictionary<ADXOlExplorerCommandBar, CommandBarNative>();
		}
		/// <summary>
		/// 
		/// </summary>
		/// <param name="container"></param>
		public ADXOlExplorerCommandBarEvents(IContainer container)
			: base(container)
		{
			this.CommandBars = new Dictionary<ADXOlExplorerCommandBar, CommandBarNative>();
			container.Add(this);
		}
		#endregion

		#region Methods
		/// <summary>
		/// 
		/// </summary>
		public void Bind()
		{
			foreach (ADXOlExplorerCommandBar bar in CommandBars.Keys)
			{
				CommandBars[bar].ReleaseHandle();
				CommandBars[bar].AssignHandle(CommandBars[bar].ObjHandle);
			}
		}
		/// <summary>
		/// 
		/// </summary>
		/// <param name="disposing"></param>
		protected override void Dispose(bool disposing)
		{
			// release handles (stop wndproc/hook)
			foreach (ADXOlExplorerCommandBar bar in CommandBars.Keys)
				CommandBars[bar].ReleaseHandle();

			base.Dispose(disposing);
		}
		/// <summary>
		/// 
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void OnMouseUpEvent(object sender, CommandBarNativeMouseEventArgs e)
		{
			if (sender is CommandBarNative)
			{
				CommandBarNative native = sender as CommandBarNative;

				foreach (ADXCommandBarControl cmdCtr in native.CommandBar.Controls)
				{
					CommandBarControl control = cmdCtr.ControlObj as CommandBarControl;

					if (control.accHitTest(e.MouseEvent.X, e.MouseEvent.Y) != null)
					{
						CommandBarControlMouseEventArgs ctrEvnt = new CommandBarControlMouseEventArgs(
									e.Cancel,
									e.MouseEvent.Button,
									e.MouseEvent.Location);

						if (this.MouseUp != null) this.MouseUp(cmdCtr, ctrEvnt);
						e.Cancel = ctrEvnt.Cancel;
					}
				}
			}
		}
		/// <summary>
		/// 
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void OnMouseDownEvent(object sender, CommandBarNativeMouseEventArgs e)
		{
			if (sender is CommandBarNative)
			{
				CommandBarNative native = sender as CommandBarNative;

				foreach (ADXCommandBarControl cmdCtr in native.CommandBar.Controls)
				{
					CommandBarControl control = cmdCtr.ControlObj as CommandBarControl;

					if (control.accHitTest(e.MouseEvent.X, e.MouseEvent.Y) != null)
					{
						CommandBarControlMouseEventArgs ctrEvnt = new CommandBarControlMouseEventArgs(
									e.Cancel,
									e.MouseEvent.Button,
									e.MouseEvent.Location);

						if (this.MouseDown != null) this.MouseDown(cmdCtr, ctrEvnt);

						e.Cancel = ctrEvnt.Cancel;
					}
				}
			}
		}
		/// <summary>
		/// 
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void OnMouseMoveEvent(object sender, ADXOlExplorerCommandBarEvents.CommandBarNativeMouseEventArgs e)
		{
			if (sender is CommandBarNative)
			{
				CommandBarNative native = sender as CommandBarNative;

				foreach (ADXCommandBarControl cmdCtr in native.CommandBar.Controls)
				{
					CommandBarControl control = cmdCtr.ControlObj as CommandBarControl;

					if (control.accHitTest(e.MouseEvent.X, e.MouseEvent.Y) != null)
					{
						CommandBarControlMouseEventArgs ctrEvnt = new CommandBarControlMouseEventArgs(
									e.Cancel,
									e.MouseEvent.Button,
									e.MouseEvent.Location);

						if (this.MouseMove != null) this.MouseMove(cmdCtr, ctrEvnt);
						e.Cancel = ctrEvnt.Cancel;
					}
				}
			}
		}
		/// <summary>
		/// 
		/// </summary>
		public void BeginInit() { }
		/// <summary>
		/// 
		/// </summary>
		public void EndInit()
		{
			foreach (IComponent component in base.Container.Components)
			{
				if (component is ADXOlExplorerCommandBar)
				{
					ADXOlExplorerCommandBar bar = component as ADXOlExplorerCommandBar;

					CommandBarNative native = new CommandBarNative(bar);
					native.MouseDownEvent += new EventHandler<CommandBarNativeMouseEventArgs>(this.OnMouseDownEvent);
					native.MouseUpEvent += new EventHandler<CommandBarNativeMouseEventArgs>(this.OnMouseUpEvent);
					native.MouseMoveEvent += new EventHandler<CommandBarNativeMouseEventArgs>(this.OnMouseMoveEvent);
					CommandBars.Add(bar, native);
				}
			}
		}
		#endregion
	}

	public class CommandBarControlMouseEventArgs : CancelEventArgs
	{
		#region Properties
		/// <summary>
		// Summary:
		///     Gets which mouse button was pressed.
		///
		/// Returns:
		///     One of the System.Windows.Forms.MouseButtons values.
		/// </summary>
		public MouseButtons Button { get; private set; }
		/// <summary>
		/// 		Summary:
		///     Gets the location of the mouse during the generating mouse event.
		///
		/// Returns:
		///     A System.Drawing.Point containing the x- and y- coordinate of the mouse,
		///     in pixels.
		/// </summary>
		public Point Location { get; private set; }
		/// <summary>
		// Summary:
		///     Gets the x-coordinate of the mouse during the generating mouse event.
		///
		/// Returns:
		///     The x-coordinate of the mouse, in pixels.
		/// </summary>
		public int X { get; private set; }
		/// <summary>
		/// Summary:
		///     Gets the y-coordinate of the mouse during the generating mouse event.
		///
		/// Returns:
		///     The y-coordinate of the mouse, in pixels.
		/// </summary>
		public int Y { get; private set; }
		#endregion

		#region Constructors
		/// <summary>
		/// 
		/// </summary>
		/// <param name="cancel"></param>
		public CommandBarControlMouseEventArgs(bool cancel, MouseButtons btn, Point location)
		{
			this.Cancel = cancel;
			this.Button = btn;
			this.Location = location;
			this.X = location.X;
			this.Y = location.Y;
		}
		#endregion
	}
}

private int _Picker = 0;
private void Timer_TICK(....)
{
       this.webbrowser.Navigate(LIST[_Picker++]);

     if(_Picker == LIST.Count -1)
     {
        // beende Timer
       _Timer.Stop();
       // reset picker
       _Picker = 0;
     }
}

		static internal void Save(string fileName, T obj)
			 {
				 this.FileName = fileName;

				 try
				 {
					 XmlSerializer serializer = new XmlSerializer(typeof(T));

					 using (TextWriter writer = new StreamWriter(fileName))
					 {
						 serializer.Serialize(writer, obj);
						 writer.Flush();
					 }
				 }
				 catch (Exception ex)
				 {
					 System.Diagnostics.Debug.Fail("Fehler beim Speichern der " + fileName + ex.Message);
					 throw;
				 }
			 }
		static internal T Load(string fileName)
		{
			try
			{
				T obj = null;
				using (TextReader reader = new StreamReader(fileName))
				{
					XmlSerializer serializer = new XmlSerializer(typeof(T));
					obj = serializer.Deserialize(reader);
				}
				return obj;
			}
			catch (Exception ex)
			{
				System.Diagnostics.Debug.Fail("Fehler beim Laden der " + fileName + ex.Message);
			}
			return null;
		}

  public enum AssemblyLocation
  {
    Gac, // Gloabl Assembly Cache
    AbsolutePath // Der Pfad ist in AssemblyName komplett angegeben
  }

  public class AssemblyActivator<T, I> : Helper.Serializer<T>
  {
    private AssemblyLocation _Location;

    public AssemblyLocation Location
    {
      get
      {
        return _Location;
      }
      set
      {
        _Location = value;
      }
    }

    private string _AssemblyName;
    public string AssemblyName
    {
      get
      {
        return _AssemblyName;
      }
      set
      {
        _AssemblyName = value;
      }
    }
    private string _ClassName;
    public string ClassName
    {
      get
      {
        return _ClassName;
      }
      set
      {
        _ClassName = value;
      }
    }

    internal I CreateObject()
    {
      Assembly a = null;
      string AssemblyPath = (Location == AssemblyLocation.CobraModule) ? 
        Cobra.APUtil.APModules.ModuleManager.ProgramDirectory + @"Module\" + AssemblyName : AssemblyName;
      try
      {
        if (Location != AssemblyLocation.Gac)
        {
          a = Assembly.LoadFrom(AssemblyPath);
        }
        else
        {
          a = Assembly.Load(AssemblyPath);
        }
      }
      catch (FileNotFoundException e)
      {
        MessageBox.Show(e.Message);
        return default(I);
      }
      Type ClassType;
      try
      {
        ClassType = a.GetType(ClassName);
      }
      catch (Exception ex)
      {
        MessageBox.Show("Class " + ClassName + " not found in Assembly " + AssemblyName + " at " + AssemblyPath + "\r\n\r\n" + ex.Message);
        return default(I);
      }
      if (ClassType == null)
      {
        MessageBox.Show("Class " + ClassName + " not found in Assembly " + AssemblyName + " at " + AssemblyPath);
        return default(I);
      }

      return (I)Activator.CreateInstance(ClassType);
    }
  }
}