public static WPFMEDIA.LineGeometry PerpendicularLine(WPF.Point StartPoint, WPF.Point EndPoint, double Length)
        {
            //Get Current Angle Don't need the actual angle, radians is fine.
            double angle = CurrentAngle(StartPoint, EndPoint);
            double radians = Math.Atan2(StartPoint.Y - EndPoint.Y, StartPoint.X - EndPoint.X);

            //Take 90 deg
            double newAngle = angle + 90;
            double newRadians = radians + Math.PI / 2;

            //need to determine the shift.

            double shiftX = Length * Math.Cos(newRadians);
            //double shiftX2 = Length * Math.Cos(newAngle * Math.PI / 180);

            double shiftY = Length * Math.Sin(newRadians);

            double newStartPointX = StartPoint.X - shiftX;
            double newStartPointY = StartPoint.Y - shiftY;

            double newEndPointX = StartPoint.X + shiftX;
            double newEndPointY = StartPoint.Y + shiftY;

            WPF.Point newStartPoint = new WPF.Point(newStartPointX, newStartPointY);
            WPF.Point newEndPoint = new WPF.Point(newEndPointX, newEndPointY);

            //get the second point

            //draw line from center of the point.
            WPFMEDIA.LineGeometry newLine = new System.Windows.Media.LineGeometry(newStartPoint, newEndPoint);
            return newLine;
        }

 //Can be more complex later.
 public static WPFMEDIA.LineGeometry Line(WPF.Point StartPoint, WPF.Point EndPoint)
 {
     WPFMEDIA.LineGeometry newLine = new System.Windows.Media.LineGeometry(StartPoint, EndPoint);
     return newLine;
 }

        //Draws a polygon with different thiknesses at each end. Traces over a line.
        public static WPFMEDIA.PathGeometry PolygonLine(WPF.Point StartPoint, WPF.Point EndPoint, double StartWidth, double EndWidth)
        {
            //Get Current Angle Don't need the actual angle, radians is fine.
            double angle = CurrentAngle(StartPoint, EndPoint);
            double radians = Math.Atan2(StartPoint.Y - EndPoint.Y, StartPoint.X - EndPoint.X);

            //Take 90 deg
            double newAngle = angle + 90;
            double newRadians = radians + Math.PI / 2;

            //need to determine the shift.

            double shiftStartX = StartWidth * Math.Cos(newRadians);
            double shiftStartY = StartWidth * Math.Sin(newRadians);

            double shiftEndX = EndWidth * Math.Cos(newRadians);
            double shiftEndY = EndWidth * Math.Sin(newRadians);

            double newStartPointX1 = StartPoint.X - shiftStartX;
            double newStartPointY1 = StartPoint.Y - shiftStartY;
            double newStartPointX2 = StartPoint.X + shiftStartX;
            double newStartPointY2 = StartPoint.Y + shiftStartY;

            double newEndPointX1 = EndPoint.X - shiftEndX;
            double newEndPointY1 = EndPoint.Y - shiftEndY;
            double newEndPointX2 = EndPoint.X + shiftEndX;
            double newEndPointY2 = EndPoint.Y + shiftEndY;

            WPF.Point newStartPoint1 = new WPF.Point(newStartPointX1, newStartPointY1);
            WPF.Point newStartPoint2 = new WPF.Point(newStartPointX2, newStartPointY2);
            WPF.Point newEndPoint1 = new WPF.Point(newEndPointX1, newEndPointY1);
            WPF.Point newEndPoint2 = new WPF.Point(newEndPointX2, newEndPointY2);

            //Now we have all the points. Need to build a polygon shape.
            WPFMEDIA.PathGeometry rootPath = new System.Windows.Media.PathGeometry();
            WPFMEDIA.PolyLineSegment poly = new System.Windows.Media.PolyLineSegment();
            //poly.Points.Add(newStartPoint1);
            poly.Points.Add(newStartPoint2);
            poly.Points.Add(newEndPoint2);
            poly.Points.Add(newEndPoint1);

            WPFMEDIA.PathFigure newFigure = new WPFMEDIA.PathFigure();
            newFigure.StartPoint = newStartPoint1;
            newFigure.Segments.Add(poly);
            rootPath.Figures.Add(newFigure);

            return rootPath;
        }

		public static bool BlurBehindWindow (sw.Window window)
		{
			if (!DwmIsCompositionEnabled ())
				return false;

			var windowInteropHelper = new sw.Interop.WindowInteropHelper (window);
			IntPtr myHwnd = windowInteropHelper.Handle;
			var mainWindowSrc = System.Windows.Interop.HwndSource.FromHwnd (myHwnd);

			window.Background = swm.Brushes.Transparent;
			mainWindowSrc.CompositionTarget.BackgroundColor = swm.Colors.Transparent;

			var blurBehindParameters = new DWM_BLURBEHIND ();
			blurBehindParameters.dwFlags = DwmBlurBehindFlags.DWM_BB_ENABLE;
			blurBehindParameters.fEnable = true;
			blurBehindParameters.hRgnBlur = IntPtr.Zero;

			DwmEnableBlurBehindWindow (myHwnd, ref blurBehindParameters);
			int val = 1;
			DwmSetWindowAttribute (myHwnd, DwmWindowAttribute.DWMWA_TRANSITIONS_FORCEDISABLED, ref val, sizeof (int));
			return true;
		}

        void GetWidgetDesiredSize(double availableWidth, double availableHeight, out SW.Size minSize, out SW.Size naturalSize)
        {
            // Calculates the desired size of widget.

            if (!Widget.IsMeasureValid) {
                try {
                    calculatingPreferredSize = true;
                    gettingNaturalSize = true;
                    Widget.Measure (new System.Windows.Size (availableWidth, availableHeight));
                    lastNaturalSize = Widget.DesiredSize;
                    gettingNaturalSize = false;

                    Widget.InvalidateMeasure ();
                    Widget.Measure (new System.Windows.Size (availableWidth, availableHeight));
                }
                finally {
                    calculatingPreferredSize = false;
                    gettingNaturalSize = false;
                }
            }
            minSize = Widget.DesiredSize;
            naturalSize = lastNaturalSize;
        }

		public Rect (SW.Rect rect)
		{
			x = rect.X;
			y = rect.Y;
			width = rect.Width;
			height = rect.Height;
		}

			/// <summary>
			/// Initializes a new instance of the MARGINS struct
			/// </summary>
			/// <param name="t">
			/// The supplied thickness
			/// </param>
			public MARGINS (sw.Thickness t)
			{
				this.Left = (int)t.Left;
				this.Right = (int)t.Right;
				this.Top = (int)t.Top;
				this.Bottom = (int)t.Bottom;
			}

		public static Size GetSize (sw.FrameworkElement element)
		{
			if (!double.IsNaN(element.ActualWidth) && !double.IsNaN(element.ActualHeight))
				return new Size ((int)element.ActualWidth, (int)element.ActualHeight);
			else
				return new Size ((int)(double.IsNaN(element.Width) ? -1 : element.Width), (int)(double.IsNaN(element.Height) ? -1 : element.Height));
		}

        public bool? InDesignMode()
        {
            #if SILVERLIGHT
            if (Application.Current.RootVisual != null) {
                return System.ComponentModel.DesignerProperties.GetIsInDesignMode(Application.Current.RootVisual);
            }

            return false;
            #elif NETFX_CORE
            return DesignMode.DesignModeEnabled;
            #else
            var designEnvironments = new[] {
                "BLEND.EXE",
                "XDESPROC.EXE",
            };

            var entry = Assembly.GetEntryAssembly();
            if (entry != null) {
                var exeName = (new FileInfo(entry.Location)).Name.ToUpperInvariant();

                if (designEnvironments.Any(x => x.Contains(exeName))) {
                    return true;
                }
            }

            return false;
            #endif
        }

 public static DialogResult ShowDesignerDialog(string title, Wpf.UIElement wpfContent, int width, int height)
 {
     DesignerDialog dlg = new DesignerDialog(title, wpfContent);
     dlg.Width = width;
     dlg.Height = height;
     dlg.SizeGripStyle = SizeGripStyle.Hide;
     return dlg.ShowDialog();
 }

		void ConnectTo (sw.Point startPoint, bool startNewFigure = false)
		{
			if (startNewFigure || figure == null) {
				figure = new swm.PathFigure ();
				figure.StartPoint = startPoint;
				figure.Segments = new swm.PathSegmentCollection ();
				Control.Figures.Add (figure);
			} else
				figure.Segments.Add (new swm.LineSegment (startPoint, true));
		}

        public static FontStretch ToXwtFontStretch(SW.FontStretch value)
        {
            // No, SW.FontStretches is not an enum
            if (value == SW.FontStretches.UltraCondensed) return FontStretch.UltraCondensed;
            if (value == SW.FontStretches.ExtraCondensed) return FontStretch.ExtraCondensed;
            if (value == SW.FontStretches.Condensed) return FontStretch.Condensed;
            if (value == SW.FontStretches.SemiCondensed) return FontStretch.SemiCondensed;
            if (value == SW.FontStretches.SemiExpanded) return FontStretch.SemiExpanded;
            if (value == SW.FontStretches.Expanded) return FontStretch.Expanded;
            if (value == SW.FontStretches.ExtraExpanded) return FontStretch.ExtraExpanded;
            if (value == SW.FontStretches.UltraExpanded) return FontStretch.UltraExpanded;

            return FontStretch.Normal;
        }

        public bool? InUnitTestRunner()
        {
            var testAssemblies = new[] {
                "CSUNIT",
                "NUNIT",
                "XUNIT",
                "MBUNIT",
                "NBEHAVE",
            };

            try {
                return searchForAssembly(testAssemblies);
            } catch (Exception) {
                return null;
            }
        }

        public Button(List<Texture2D> textures, DotNET.Point location, long minInteractionTime)
        {
            this.textures = textures;
            this.Location = location;
            representation = 0;
            this.numTextures = textures.Count;

            radius = ((textures[0].Height / 2) + (textures[0].Width / 2)) / 2;
            radiusSq = radius * radius;

            minNecessaryInteractionTime = minInteractionTime;
            stopwatch = new Stopwatch();

            people = new Person[6];

            buttonHasBeenTriggered = false;

            timingInteraction = false;
        }

        public bool? InUnitTestRunner()
        {
            var testAssemblies = new[] {
                "CSUNIT",
                "NUNIT",
                "XUNIT",
                "MBUNIT",
                "NBEHAVE",
                "VISUALSTUDIO.QUALITYTOOLS",
                "FIXIE",
                "NCRUNCH",
            };

            try {
                return searchForAssembly(testAssemblies);
            } catch (Exception) {
                return null;
            }
        }

 /// <summary>
 /// Offsets a point in a particular direction by certian length.
 /// </summary>
 /// <param name="p1"></param>
 /// <param name="dir"></param>
 /// <param name="len"></param>
 /// <returns></returns>
 public static Point Offset(Point p1, windows.Vector dir, float len)
 {
     return new Point((int)(p1.X + dir.X * len / dir.Length),
       (int)(p1.Y + dir.Y * len / dir.Length));
 }

 public static double DistanceBetweenPoints(WPF.Point StartPoint, WPF.Point EndPoint)
 {
     double length = Math.Sqrt(Math.Pow(StartPoint.X - EndPoint.X, 2) + Math.Pow(StartPoint.Y - EndPoint.Y, 2));
     return length;
 }

 public static double CurrentAngle(WPF.Point StartPoint, WPF.Point EndPoint)
 {
     double radians = Math.Atan2(StartPoint.Y - EndPoint.Y, StartPoint.X - EndPoint.X);
     double angle = radians * (180 / Math.PI);
     return angle;
 }

 public void NewFigure(SW.Point p)
 {
     if (Path.Segments.Count > 0) {
         Path = new PathFigure ();
         geometry.Figures.Add (Path);
     }
     LastFigureStart = p;
     EndPoint = p;
     Path.StartPoint = p;
     positionSet = true;
 }

 public void ConnectToLastFigure(SW.Point p, bool stroke)
 {
     if (EndPoint != p) {
         var pathIsOpen = Path.Segments.Count != 0 || geometry.Figures.Count > 1 || positionSet;
         if (pathIsOpen) {
         //	LastFigureStart = p;
             Path.Segments.Add (new LineSegment (p, stroke));
         }
         else
             NewFigure (p);
     }
     if (!stroke)
         LastFigureStart = p;
 }