2007-03-19 Chris Toshok <toshok@ximian.com>

[mono-project.git] / mcs / class / Managed.Windows.Forms / System.Windows.Forms / XEventQueue.cs

// 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) 2004-2006 Novell, Inc.
//
// System.Windows.Forms.XEventQueue
//
// Authors:
//  Jackson Harper (jackson@ximian.com)
//  Peter Dennis Bartok (pbartok@novell.com)
//

using System;
using System.Threading;
using System.Collections;

namespace System.Windows.Forms {

        internal class XEventQueue {

                private XQueue          xqueue;
                private XQueue          lqueue; // Events inserted from threads other then the main X thread
                private PaintQueue      paint;  // Paint-only queue
                internal ArrayList      timer_list;
                private Thread          thread;
                private bool            dispatch_idle;

                private static readonly int InitialXEventSize = 100;
                private static readonly int InitialLXEventSize = 10;
                private static readonly int InitialPaintSize = 50;

                public XEventQueue (Thread thread) {
                        xqueue = new XQueue (InitialXEventSize);
                        lqueue = new XQueue (InitialLXEventSize);
                        paint = new PaintQueue(InitialPaintSize);
                        timer_list = new ArrayList ();
                        this.thread = thread;
                        this.dispatch_idle = true;
                }

                public int Count {
                        get {
                                lock (lqueue) {
                                        return xqueue.Count + lqueue.Count;
                                }
                        }
                }

                public PaintQueue Paint {
                        get {
                                return paint;
                        }
                }

                public Thread Thread {
                        get {
                                return thread;
                        }
                }

                public void Enqueue (XEvent xevent)
                {
                        if (Thread.CurrentThread != thread) {
                                Console.WriteLine ("Hwnd.Queue.Enqueue called from a different thread without locking.");
                                Console.WriteLine (Environment.StackTrace);
                        }

                        xqueue.Enqueue (xevent);
                }

                public void EnqueueLocked (XEvent xevent)
                {
                        lock (lqueue) {
                                lqueue.Enqueue (xevent);
                        }
                }

                public XEvent Dequeue ()
                {
                        if (Thread.CurrentThread != thread) {
                                Console.WriteLine ("Hwnd.Queue.Dequeue called from a different thread without locking.");
                                Console.WriteLine (Environment.StackTrace);
                        }

                        if (xqueue.Count == 0) {
                                lock (lqueue) {
                                        return lqueue.Dequeue ();
                                }
                        }
                        return xqueue.Dequeue ();
                }

                public XEvent Peek()
                {
                        if (Thread.CurrentThread != thread) {
                                Console.WriteLine ("Hwnd.Queue.Peek called from a different thread without locking.");
                                Console.WriteLine (Environment.StackTrace);
                        }

                        if (xqueue.Count == 0) {
                                lock (lqueue) {
                                        return lqueue.Peek ();
                                }
                        }                               
                        return xqueue.Peek();
                }

                public bool DispatchIdle {
                        get {
                                return dispatch_idle;
                        }
                        set {
                                dispatch_idle = value;
                        }
                }

                public class PaintQueue {

                        private ArrayList       hwnds;
                        private XEvent          xevent;
                        
                        public PaintQueue (int size) {
                                hwnds = new ArrayList(size);
                                xevent = new XEvent();
                                xevent.AnyEvent.type = XEventName.Expose;
                        }

                        public int Count {
                                get { return hwnds.Count; }
                        }

                        public void Enqueue (Hwnd hwnd) {
                                hwnds.Add(hwnd);
                        }

                        public void Remove(Hwnd hwnd) {
                                if (!hwnd.expose_pending && !hwnd.nc_expose_pending) {
                                        hwnds.Remove(hwnd);
                                }
                        }

                        public XEvent Dequeue () {
                                Hwnd            hwnd;
                                IEnumerator     next;

                                if (hwnds.Count == 0) {
                                        xevent.ExposeEvent.window = IntPtr.Zero;
                                        return xevent;
                                }

                                next = hwnds.GetEnumerator();
                                next.MoveNext();
                                hwnd = (Hwnd)next.Current;

                                // We only remove the event from the queue if we have one expose left since
                                // a single 'entry in our queue may be for both NC and Client exposed
                                if ( !(hwnd.nc_expose_pending && hwnd.expose_pending)) {
                                        hwnds.Remove(hwnd);
                                }
                                if (hwnd.expose_pending) {
                                        xevent.ExposeEvent.window = hwnd.client_window;
#if not
                                        xevent.ExposeEvent.x = hwnd.invalid.X;
                                        xevent.ExposeEvent.y = hwnd.invalid.Y;
                                        xevent.ExposeEvent.width = hwnd.invalid.Width;
                                        xevent.ExposeEvent.height = hwnd.invalid.Height;
#endif
                                        return xevent;
                                } else {
                                        xevent.ExposeEvent.window = hwnd.whole_window;
                                        xevent.ExposeEvent.x = hwnd.nc_invalid.X;
                                        xevent.ExposeEvent.y = hwnd.nc_invalid.Y;
                                        xevent.ExposeEvent.width = hwnd.nc_invalid.Width;
                                        xevent.ExposeEvent.height = hwnd.nc_invalid.Height;
                                        return xevent;
                                }
                        }
                }

                private class XQueue {

                        private XEvent [] xevents;
                        private int head;
                        private int tail;
                        private int size;
                        
                        public XQueue (int size)
                        {
                                xevents = new XEvent [size];
                        }

                        public int Count {
                                get { return size; }
                        }

                        public void Enqueue (XEvent xevent)
                        {
                                if (size == xevents.Length)
                                        Grow ();
                                
                                xevents [tail] = xevent;
                                tail = (tail + 1) % xevents.Length;
                                size++;
                        }

                        public XEvent Dequeue ()
                        {
                                if (size < 1)
                                        throw new Exception ("Attempt to dequeue empty queue.");
                                XEvent res = xevents [head];
                                head = (head + 1) % xevents.Length;
                                size--;
                                return res;
                        }

                        public XEvent Peek() {
                                if (size < 1) {
                                        throw new Exception ("Attempt to peek at empty queue");
                                }
                                return xevents[head];
                        }

                        private void Grow ()
                        {
                                int newcap = (xevents.Length * 2);
                                XEvent [] na = new XEvent [newcap];
                                xevents.CopyTo (na, 0);
                                xevents = na;
                                head = 0;
                                tail = head + size;
                        }
                }
        }
}