C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

namespace howto_list_desktop_windows
{
    static class DesktopWindowsStuff
    {
        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool IsWindowVisible(IntPtr hWnd);
         [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool IsIconic(IntPtr hWnd);
         [DllImport("user32.dll", EntryPoint = "GetWindowText",
        ExactSpelling = false, CharSet = CharSet.Auto, SetLastError = true)]
              private static extern int GetWindowText(IntPtr hWnd,
            StringBuilder lpWindowText, int nMaxCount);
        [DllImport("user32.dll", EntryPoint = "EnumDesktopWindows",
        ExactSpelling = false, CharSet = CharSet.Auto, SetLastError = true)]
        private static extern bool EnumDesktopWindows(IntPtr hDesktop,
            EnumDelegate lpEnumCallbackFunction, IntPtr lParam);
        // Define the callback delegate's type.
        private delegate bool EnumDelegate(IntPtr hWnd, int lParam);
        // Save window titles and handles in these lists.
        private static List<IntPtr> WindowHandles;
        private static List<string> WindowTitles;
        // Return a list of the desktop windows' handles and titles.
        public static void GetDesktopWindowHandlesAndTitles(
            out List<IntPtr> handles, out List<string> titles)
        {
            WindowHandles = new List<IntPtr>();
            WindowTitles = new List<string>();
            if (!EnumDesktopWindows(IntPtr.Zero, FilterCallback, IntPtr.Zero))
            {
                handles = null;
                titles = null;
            }
            else
            {
              //  handles = null;
              handles = WindowHandles;
              titles = WindowTitles;
            }
        }
        // We use this function to filter windows.
        // This version selects visible windows that have titles.
        private static bool FilterCallback(IntPtr hWnd, int lParam)
        {
            // Get the window's title.
            StringBuilder sb_title = new StringBuilder(1024);
            int length = GetWindowText(hWnd, sb_title, sb_title.Capacity);
            string title = sb_title.ToString();           
            // If the window is visible and has a title, save it.
            if (IsWindowVisible(hWnd) && string.IsNullOrEmpty(title) == false)
            {
           //exclude minimized windows
                if (IsIconic(hWnd) == false)
                { 
                    {
                        WindowHandles.Add(hWnd);
                        WindowTitles.Add(title);
                    }
                }
            }

            // Return true to indicate that we
            // should continue enumerating windows.
            return true;
        }
    }
}

    textBox.Text = "";

    Thread.CurrentThread.Name = "UI Thread";

    IScheduler thread1 = new NewThreadScheduler(x => new Thread(x) { Name = "Thread1" });

    TimeSpan RetryMaxTime = new TimeSpan(0, 0, 0,0,5);
    Observable.Create<int>(o =>
    {
        Console.WriteLine("Created on " + Thread.CurrentThread.Name);
        o.OnNext(1);
        o.OnError(new Exception("Something random just happened"));
        o.OnCompleted();
        return Disposable.Create(() => { });
    })
    .SubscribeOn(thread1)
    .Retry(RetryMaxTime)
    .ObserveOnDispatcher()
    .Subscribe(
        x =>
        {
            textBox.Text += x.ToString() + Environment.NewLine;
        }
        , ex => textBox.Text += ex.Message
        , () => { textBox.Text += "Completed on " + Thread.CurrentThread.Name; }
        );
}

public static class MyExtensions
{

    public static IObservable<TItem> Retry<TItem>(this IObservable<TItem> collection,TimeSpan ExceptionTimeout)
    {
        return Observable.Create<TItem>(obs =>
        {
            var weakSubscription = new WeakSubscription<TItem>(collection, obs, ExceptionTimeout);
            return () =>
            {
                weakSubscription.Dispose();
            };
        });
    }

    public class WeakSubscription<T> : IDisposable, IObserver<T>
    {
        private readonly WeakReference reference;
        private readonly IDisposable subscription;
        private Exception LastError;
        private bool EndRetry = false;
        private bool disposed;

      private System.Windows.Threading.DispatcherTimer dispatcherTimer = new System.Windows.Threading.DispatcherTimer();

        public WeakSubscription(IObservable<T> observable, IObserver<T> observer, TimeSpan ExceptionTimeout)
        {
            this.reference = new WeakReference(observer);

            var interval = Observable.Interval(ExceptionTimeout);
            interval.SubscribeOn(Scheduler.CurrentThread).Subscribe(x =>
            EndRetry = true);
            this.subscription = observable.Retry()//.Subscribe(this);
                .Catch<T>(e=>e)
                //{
                    //LastError = error;
                  //  return Observable.Return("test");
                  //  })
            .Subscribe(this);

        }

        IObservable<T> ExceptionHappened(Exception ex)
        {
            return null;
        }

        void IObserver<T>.OnCompleted()
        {
            var observer = (IObserver<T>)this.reference.Target;
            if (observer != null)
                observer.OnCompleted();

            if (this.EndRetry)
                this.Dispose();

        }

        void IObserver<T>.OnError(Exception error)
        {
            var observer = (IObserver<T>)this.reference.Target;
            LastError = error;

            if (observer != null)
                observer.OnError(error);
            if (this.EndRetry)
                this.Dispose();
        }

        void IObserver<T>.OnNext(T value)
        {
            var observer = (IObserver<T>)this.reference.Target;

            if (observer != null)
                observer.OnNext(value);
            if (this.EndRetry)
                this.Dispose();

        }

        public void Dispose()
        {
            if (!this.disposed)
            {
                this.disposed = true;
                this.subscription.Dispose();
            }
        }
    }

}

private void pictureBox1_VisibleChanged(object sender, EventArgs e)
        {
            pictureBox1.SizeMode = PictureBoxSizeMode.StretchImage;
            

        }
       
        private void pictureBox1_Click(object sender, EventArgs e)
        {
            MouseEventArgs me = (MouseEventArgs)e;
            if (me.Button == System.Windows.Forms.MouseButtons.Right)
            {
                switch (clickProgress)
                {
                    case 1:
                        pts[2] = pts[0];
                        pts[1] = pts[0];
                        clickProgress--;
                        break;
                    case 2:
                        pts[2] = pts[0];
                        clickProgress--;
                        break;
                    case 3:
                        clickProgress--;
                        break;
                }
            }
            if (me.Button == System.Windows.Forms.MouseButtons.Left)
            {
                if (clickProgress < 3)
                {
                    pts[clickProgress] = me.Location;
                    if (clickProgress == 0)
                    {
                        pts[1] = pts[0];
                        pts[2] = pts[0];
                    }
                    clickProgress++;
                }
            }

            updateBitmap();
        }

        private void pictureBox1_MouseMove(object sender, MouseEventArgs e)
        {
            if (clickProgress > 0 && clickProgress < 3)
                pts[clickProgress] = e.Location;

            updateBitmap();
        }


        private void updateBitmap()
        {
            if (pictureBox1.Image == null)
            {
                Bitmap bmp = new Bitmap(pictureBox1.Width, pictureBox1.Height);
                
                pictureBox1.Image = bmp;
                
            }

            using (Graphics g = Graphics.FromImage(pictureBox1.Image))
            {
                g.Clear(Color.Black);
                
               
                if (pic != null)
                {
                    int width = pictureBox1.Width;
                    int height = pictureBox1.Height;

                    float scaleW = pictureBox1.Width * 1.0f / width;
                    float scaleH = pictureBox1.Height * 1.0f / height;
                    float scale = scaleW;
                    if (scale > scaleH)
                        scale = scaleH;

                    int nw = (int)(scale * width);
                    int nh = (int)(scale * height);

                    if (picScaled == null)
                    {
                        RectangleF sourceRect = new RectangleF(0, 0, width, height);
                        RectangleF destinationRect = new RectangleF(0, 0, nw, nh);
                        picScaled = new Bitmap(nw, nh);

                        Graphics gi = Graphics.FromImage(picScaled);
                        gi.DrawImage(
                            pic,
                            destinationRect,
                            sourceRect,
                            GraphicsUnit.Pixel);
                        gi.Dispose();
                    }
                    {
                        RectangleF sourceRect = new RectangleF(0, 0, nw, nh);

                        RectangleF destinationRect = new RectangleF(
                            pictureBox1.Width / 2 - nw / 2,
                            pictureBox1.Height / 2 - nh / 2,
                            nw,
                            nh);

                        g.DrawImage(
                            picScaled,
                            destinationRect,
                            sourceRect,
                            GraphicsUnit.Pixel);
                    }
                }

                Pen greenPen = new Pen(Brushes.Green);
                greenPen.Width = 3.0F;
                Pen redPen = new Pen(Brushes.Red);
                redPen.Width = 3.0F;

                if (clickProgress > 0)
                    g.DrawLine(greenPen, pts[0], pts[1]);

                if (clickProgress > 1)
                    g.DrawLine(redPen, pts[0], pts[2]);

                redPen.Dispose();
                greenPen.Dispose();
            }
            pictureBox1.Invalidate();

            if (clickProgress > 1)
            {

                Point p0 = new Point(pts[1].X - pts[0].X, pts[1].Y - pts[0].Y);
                Point p1 = new Point(pts[2].X - pts[0].X, pts[2].Y - pts[0].Y);

                ///make these doubles to not overflow
                double l0 = (p0.X * p0.X + p0.Y * p0.Y);
                double l1 = (p1.X * p1.X + p1.Y * p1.Y);

                double d = ((double)p0.X * p1.X + (double)p0.Y * p1.Y) / Math.Sqrt(l0 * l1);

                if (d > +1) d = +1;//limit against roundoff errors
                if (d < -1) d = -1;//limit against roundoff errors

                if (l0 > 0 && l1 > 0)
                    label1.Text = (Math.Acos(d) * 180 / Math.PI).ToString("0.0", System.Globalization.CultureInfo.InvariantCulture);
            }
            else
            {
                label1.Text = "";
            }
        }