+// 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
//
-// Author(s):
+// Authors:
// Jackson Harper (jackson@ximian.com)
-//
-// Copyright (C) Novell, Inc (http://www.novell.com)
+// Peter Dennis Bartok (pbartok@novell.com)
//
using System;
using System.Threading;
using System.Collections;
-
namespace System.Windows.Forms {
internal class XEventQueue {
- private XEvent [] xevents;
- private XEvent [] lxevents; // Events inserted from threads other then the main X thread
-
- private int xindex;
- private int lxindex;
+ 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;
+ }
- private static readonly int MinXEventSize = 50;
- private static readonly int MinLXEventSize = 10;
+ public int Count {
+ get {
+ lock (lqueue) {
+ return xqueue.Count + lqueue.Count;
+ }
+ }
+ }
- public XEventQueue ()
- {
- xevents = new XEvent [MinXEventSize];
- xevents = new XEvent [MinLXEventSize];
+ public PaintQueue Paint {
+ get {
+ return paint;
+ }
}
- public int Count {
- get { return xindex + lxindex; }
+ public Thread Thread {
+ get {
+ return thread;
+ }
}
public void Enqueue (XEvent xevent)
{
- EnqueueArray (xevent, ref xevents, ref xindex);
+ 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 (lxevents) {
- EnqueueArray (xevent, ref lxevents, ref lxindex);
+ lock (lqueue) {
+ lqueue.Enqueue (xevent);
}
}
public XEvent Dequeue ()
{
- if (xindex == 0) {
- lock (lxevents) {
- return DequeueArray (ref lxevents, ref lxindex);
+ 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 ();
}
- if (lxindex == 0)
- throw new Exception ("No more items in XQueue");
- return lxevents [lxindex--];
}
- return xevents [xindex--];
+ return xqueue.Dequeue ();
}
- public void CheckSize ()
+ public XEvent Peek()
{
- CheckArraySize (ref xevents, MinXEventSize, xindex);
-
- lock (lxevents) {
- CheckArraySize (ref lxevents, MinLXEventSize, lxindex);
+ 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 void CheckArraySize (ref XEvent [] array, int min, int index)
- {
- if (array.Length > min && index * 3 < array.Length) {
- XEvent [] na = new XEvent [min];
- Array.Copy (array, na, index);
+ public bool DispatchIdle {
+ get {
+ return dispatch_idle;
+ }
+ set {
+ dispatch_idle = value;
}
}
- private void EnqueueArray (XEvent xevent, ref XEvent [] array, ref int index)
- {
- index++;
- if (index == array.Length) {
- XEvent [] na = new XEvent [array.Length * 2];
- Array.Copy (array, na, array.Length);
- array = na;
+ 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; }
}
- array [index] = xevent;
+ 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 XEvent DequeueArray (ref XEvent [] array, ref int index)
- {
- return array [index--];
+ 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;
+ }
}
}
}
projects / mono.git / blobdiff