// Constructor.
	public DrawingWindowBuffer(IToolkitWindow windowToBuffer)
			{
				toolkit = windowToBuffer.Toolkit;
				widget = windowToBuffer as InputOutputWidget;
				buffer = null;
				graphics = null;
			}
Пример #2
0
 // Get the display and screen from a widget, after checking for null.
 private static Display GetDisplay(InputOutputWidget widget)
 {
     if (widget == null)
     {
         throw new ArgumentNullException("widget");
     }
     return(widget.dpy);
 }
Пример #3
0
 private static Screen GetScreen(InputOutputWidget widget)
 {
     if (widget == null)
     {
         throw new ArgumentNullException("widget");
     }
     return(widget.screen);
 }
Пример #4
0
 // Send a fake "LeaveNotify" event to a popup window.
 private static void FakeLeave(InputOutputWidget window)
 {
     if (window != null)
     {
         XEvent xevent = new XEvent();
         xevent.xany.type__ =
             (Xlib.Xint)(int)(EventType.LeaveNotify);
         window.DispatchEvent(ref xevent);
     }
 }
Пример #5
0
        /// <summary>
        /// <para>Constructs a new <see cref="T:Xsharp.DoubleBuffer"/>
        /// instance.</para>
        /// </summary>
        ///
        /// <param name="widget">
        /// <para>The widget to attach the double buffer to.</para>
        /// </param>
        ///
        /// <exception cref="T:System.ArgumentNullException">
        /// <para>Raised if <paramref name="widget"/> is <see langword="null"/>.
        /// </para>
        /// </exception>
        public DoubleBuffer(InputOutputWidget widget)
            : base(GetDisplay(widget), GetScreen(widget),
                   DrawableKind.DoubleBuffer)
        {
            this.widget = widget;
            this.width  = widget.width;
            this.height = widget.height;
            try
            {
                IntPtr display = dpy.Lock();

                // Determine if the X server supports double buffering.
                try
                {
                    Xlib.Xint major, minor;
                    if (Xlib.XdbeQueryExtension
                            (display, out major, out minor)
                        != XStatus.Zero)
                    {
                        usesXdbe = true;
                    }
                    else
                    {
                        usesXdbe = false;
                    }
                }
                catch (Exception)
                {
                    // Xdbe functions are not present in "Xext".
                    usesXdbe = false;
                }

                // Create the back buffer or pixmap, as appropriate.
                if (usesXdbe)
                {
                    handle = Xlib.XdbeAllocateBackBufferName
                                 (display, widget.GetWidgetHandle(),
                                 Xlib.XdbeSwapAction.Background);
                }
                else
                {
                    handle = (XDrawable)
                             Xlib.XCreatePixmap
                                 (display, (XDrawable)
                                 Xlib.XRootWindowOfScreen(screen.screen),
                                 (uint)width, (uint)height,
                                 (uint)Xlib.XDefaultDepthOfScreen
                                     (screen.screen));
                }
            }
            finally
            {
                dpy.Unlock();
            }
        }
Пример #6
0
	/// <summary>
	/// <para>Constructs a new <see cref="T:Xsharp.DoubleBuffer"/>
	/// instance.</para>
	/// </summary>
	///
	/// <param name="widget">
	/// <para>The widget to attach the double buffer to.</para>
	/// </param>
	///
	/// <exception cref="T:System.ArgumentNullException">
	/// <para>Raised if <paramref name="widget"/> is <see langword="null"/>.
	/// </para>
	/// </exception>
	public DoubleBuffer(InputOutputWidget widget)
			: base(GetDisplay(widget), GetScreen(widget),
			       DrawableKind.DoubleBuffer)
			{
				this.widget = widget;
				this.width = widget.width;
				this.height = widget.height;
				try
				{
					IntPtr display = dpy.Lock();

					// Determine if the X server supports double buffering.
					try
					{
						Xlib.Xint major, minor;
						if(Xlib.XdbeQueryExtension
							(display, out major, out minor)
								!= XStatus.Zero)
						{
							usesXdbe = true;
						}
						else
						{
							usesXdbe = false;
						}
					}
					catch(Exception)
					{
						// Xdbe functions are not present in "Xext".
						usesXdbe = false;
					}

					// Create the back buffer or pixmap, as appropriate.
					if(usesXdbe)
					{
						handle = Xlib.XdbeAllocateBackBufferName
							(display, widget.GetWidgetHandle(),
							 Xlib.XdbeSwapAction.Background);
					}
					else
					{
						handle = (XDrawable)
							Xlib.XCreatePixmap
								(display, (XDrawable)
								   Xlib.XRootWindowOfScreen(screen.screen),
								 (uint)width, (uint)height,
								 (uint)Xlib.XDefaultDepthOfScreen
								 	(screen.screen));
					}
				}
				finally
				{
					dpy.Unlock();
				}
			}
Пример #7
0
        // Process pending invalidates.
        private void ProcessPendingInvalidates()
        {
            InputOutputWidget current = invalidateList;
            InputOutputWidget next;

            invalidateList = null;
            while (current != null)
            {
                next = current.nextInvalidate;
                current.FlushInvalidates();
                current = next;
            }
        }
Пример #8
0
 // Find the child window that has the focus
 private InputOutputWidget FindFocusedChild(InputOutputWidget parent)
 {
     if (parent != null)
     {
         foreach (InputOutputWidget child in parent)
         {
             if (child.Focused)
             {
                 return(child);
             }
         }
     }
     return(null);
 }
Пример #9
0
        // Flush pending invalidates to the X server.
        internal void FlushInvalidates()
        {
            Region region = invalidateRegion;

            invalidateRegion = null;
            nextInvalidate   = null;
            if (region != null)
            {
                // No point redrawing if we are unmapped.
                if (handle != XDrawable.Zero && mapped && AncestorsMapped)
                {
                    Invalidate(region);
                }
            }
        }
Пример #10
0
        // Remove a popup from the mapped list.
        public void RemovePopup(PopupWindow popup)
        {
            int index;

            lock (this)
            {
                for (index = list.Length - 1; index >= 0; --index)
                {
                    if (list[index] == popup)
                    {
                        // Remove the item from the list.
                        PopupWindow[] newList;
                        newList = new PopupWindow [list.Length - 1];
                        Array.Copy(list, 0, newList, 0, index);
                        Array.Copy(list, index + 1, newList, index,
                                   list.Length - index - 1);
                        list = newList;

                        // If this was the entered window, then
                        // send it a fake "LeaveNotify" event.
                        if (lastChildEntered != null &&
                            lastChildEntered.Parent == popup)
                        {
                            FakeLeave(lastChildEntered);
                            lastChildEntered = null;
                        }
                        if (lastEntered == popup)
                        {
                            lastEntered = null;
                            FakeLeave(popup);
                        }

                        // If this was the button window, then clear it.
                        if (lastButton == popup)
                        {
                            lastButton = null;
                        }

                        // If the list is now empty, then ungrab.
                        if (list.Length == 0)
                        {
                            Ungrab();
                        }
                        return;
                    }
                }
            }
        }
Пример #11
0
 // Find the child window that contains a particular mouse position
 private InputOutputWidget FindChild(InputOutputWidget parent, int x, int y)
 {
     if (parent != null)
     {
         foreach (InputOutputWidget child in parent)
         {
             if (child.IsMapped &&
                 x - parent.X >= child.X &&
                 x - parent.X < (child.X + child.Width) &&
                 y - parent.Y >= child.y &&
                 y - parent.Y < (child.Y + child.Height))
             {
                 return(child);
             }
         }
     }
     return(null);
 }
Пример #12
0
        // Change the "lastEntered" and "lastChildEntered" window.
        // The popup is entered before the child and left after.
        private void ChangeEntered(PopupWindow popup, InputOutputWidget child)
        {
            PopupWindow       before      = null;
            PopupWindow       after       = null;
            InputOutputWidget childBefore = null;
            InputOutputWidget childAfter  = null;

            lock (this)
            {
                if (lastEntered != popup)
                {
                    before      = lastEntered;
                    after       = popup;
                    lastEntered = popup;
                }
                if (lastChildEntered != child)
                {
                    childBefore      = lastChildEntered;
                    childAfter       = child;
                    lastChildEntered = child;
                }
            }
            if (before != null)
            {
                if (childBefore != null)
                {
                    FakeLeave(childBefore);
                }
                FakeLeave(before);
            }
            if (after != null)
            {
                FakeEnter(after);
                if (childAfter != null)
                {
                    FakeEnter(childAfter);
                }
            }
        }
Пример #13
0
        // Remove an input/output widget from the pending expose list.
        internal void RemovePendingExpose(InputOutputWidget widget)
        {
            InputOutputWidget current, prev;

            current = exposeList;
            prev    = null;
            while (current != null && current != widget)
            {
                prev    = current;
                current = current.nextExpose;
            }
            if (current != null)
            {
                if (prev != null)
                {
                    prev.nextExpose = current.nextExpose;
                }
                else
                {
                    exposeList = current.nextExpose;
                }
            }
        }
Пример #14
0
        // Remove an input/output widget from the pending invalidate list.
        internal void RemovePendingInvalidate(InputOutputWidget widget)
        {
            InputOutputWidget current, prev;

            current = invalidateList;
            prev    = null;
            while (current != null && current != widget)
            {
                prev    = current;
                current = current.nextInvalidate;
            }
            if (current != null)
            {
                if (prev != null)
                {
                    prev.nextInvalidate = current.nextInvalidate;
                }
                else
                {
                    invalidateList = current.nextInvalidate;
                }
            }
        }
Пример #15
0
 // Get the background information for use in graphics object clears.
 internal void GetBackgroundInfo(out Color bg, out Pixmap pixmap,
                                 out int tx, out int ty)
 {
     if (background.Index == StandardColor.Inherit)
     {
         InputOutputWidget parent =
             (Parent as InputOutputWidget);
         if (parent != null)
         {
             parent.GetBackgroundInfo
                 (out bg, out pixmap, out tx, out ty);
             tx -= x;
             ty -= y;
         }
         else
         {
             bg     = new Color(StandardColor.Background);
             pixmap = null;
             tx     = 0;
             ty     = 0;
         }
     }
     else if (background.Index == StandardColor.Pixmap)
     {
         bg     = background;
         pixmap = backgroundPixmap;
         tx     = 0;
         ty     = 0;
     }
     else
     {
         bg     = background;
         pixmap = null;
         tx     = 0;
         ty     = 0;
     }
 }
Пример #16
0
 // Add an input/output widget to the pending expose list.
 internal void AddPendingExpose(InputOutputWidget widget)
 {
     widget.nextExpose = exposeList;
     exposeList        = widget;
     pendingExposes    = true;
 }
Пример #17
0
	// Find the child window that has the focus
	private InputOutputWidget FindFocusedChild(InputOutputWidget parent)
			{
				if (parent != null)
				{
					foreach(InputOutputWidget child in parent)
					{
						if (child.Focused)
							return child;
					}
				}
				return null;
			}
Пример #18
0
 // Add an input/output widget to the pending invalidate list.
 internal void AddPendingInvalidate(InputOutputWidget widget)
 {
     widget.nextInvalidate = invalidateList;
     invalidateList        = widget;
 }
Пример #19
0
	// Get the display and screen from a widget, after checking for null.
	private static Display GetDisplay(InputOutputWidget widget)
			{
				if(widget == null)
				{
					throw new ArgumentNullException("widget");
				}
				return widget.dpy;
			}
Пример #20
0
        // Dispatch an event to this widget.
        internal override void DispatchEvent(ref XEvent xevent)
        {
            XKeySym           keysym;
            PopupWindow       popup;
            InputOutputWidget child = null;

            switch ((EventType)(xevent.xany.type__))
            {
            case EventType.ButtonPress:
            {
                // A mouse button was pressed during the grab.
                lock (this)
                {
                    if (lastButton != null)
                    {
                        // We currently have a button window, so
                        // all mouse events should go to it.
                        popup = lastButton;
                    }
                    else
                    {
                        // Determine which popup contains the mouse.
                        // If nothing contains, then use the top.
                        popup = Find(xevent.xbutton.x_root,
                                     xevent.xbutton.y_root, true);
                    }
                    lastButton = popup;
                }
                // Find the child window.
                child = FindChild(popup, xevent.xbutton.x_root,
                                  xevent.xbutton.y_root);
                ChangeEntered(popup, child);
                if (popup != null)
                {
                    // Adjust the co-ordinates and re-dispatch.
                    xevent.xbutton.x__ =
                        (Xlib.Xint)(xevent.xbutton.x_root - popup.x);
                    xevent.xbutton.y__ =
                        (Xlib.Xint)(xevent.xbutton.y_root - popup.y);
                    popup.DispatchEvent(ref xevent);
                    // Re-dispatch to the child window if necessary.
                    if (child != null)
                    {
                        xevent.xbutton.x__ -= child.x;
                        xevent.xbutton.y__ -= child.y;
                        child.DispatchEvent(ref xevent);
                    }
                }
            }
            break;

            case EventType.ButtonRelease:
            {
                // A mouse button was released during the grab.
                lock (this)
                {
                    popup = lastButton;
                    if (popup != null)
                    {
                        // Reset "lastButton" if this is the last
                        // button to be released.
                        ModifierMask mask = ModifierMask.AllButtons;
                        mask &= (ModifierMask) ~((int)ModifierMask.Button1Mask <<
                                                 ((int)(xevent.xbutton.button__) - 1));
                        if ((xevent.xbutton.state & mask) == 0)
                        {
                            lastButton = null;
                        }
                    }
                }
                // Find the child window.
                child = FindChild(popup, xevent.xbutton.x_root,
                                  xevent.xbutton.y_root);
                ChangeEntered(popup, child);
                if (popup != null)
                {
                    // Adjust the co-ordinates and re-dispatch.
                    xevent.xbutton.x__ =
                        (Xlib.Xint)(xevent.xbutton.x_root - popup.x);
                    xevent.xbutton.y__ =
                        (Xlib.Xint)(xevent.xbutton.y_root - popup.y);
                    popup.DispatchEvent(ref xevent);
                    // Re-dispatch to the child window if necessary.
                    if (child != null)
                    {
                        xevent.xbutton.x__ -= child.x;
                        xevent.xbutton.y__ -= child.y;
                        child.DispatchEvent(ref xevent);
                    }
                }
            }
            break;

            case EventType.MotionNotify:
            {
                // The mouse pointer was moved during the grab.
                lock (this)
                {
                    // If there is a last button window, then use
                    // that, otherwise find the one under the mouse.
                    popup = lastButton;
                    if (popup == null)
                    {
                        popup = Find(xevent.xmotion.x_root,
                                     xevent.xmotion.y_root, false);
                    }
                }
                // Find the child window.
                child = FindChild(popup, xevent.xbutton.x_root,
                                  xevent.xbutton.y_root);
                ChangeEntered(popup, child);
                if (popup != null)
                {
                    // Adjust the co-ordinates and re-dispatch.
                    xevent.xmotion.x__ =
                        (Xlib.Xint)(xevent.xmotion.x_root - popup.x);
                    xevent.xmotion.y__ =
                        (Xlib.Xint)(xevent.xmotion.y_root - popup.y);
                    popup.DispatchEvent(ref xevent);
                    // Re-dispatch to the child window if necessary.
                    if (child != null)
                    {
                        xevent.xbutton.x__ -= child.x;
                        xevent.xbutton.y__ -= child.y;
                        child.DispatchEvent(ref xevent);
                    }
                }
            }
            break;

            case EventType.KeyPress:
            {
                // Convert the event into a symbol and a string.
                if (keyBuffer == IntPtr.Zero)
                {
                    keyBuffer = Marshal.AllocHGlobal(32);
                }
                keysym = 0;
                int len = Xlib.XLookupString
                              (ref xevent.xkey, keyBuffer, 32,
                              ref keysym, IntPtr.Zero);
                String str;
                if (len > 0)
                {
                    str = Marshal.PtrToStringAnsi(keyBuffer, len);
                }
                else
                {
                    str = null;
                }

                // Dispatch the event to the top-most popup.
                lock (this)
                {
                    if (list.Length > 0)
                    {
                        popup = list[list.Length - 1];
                    }
                    else
                    {
                        popup = null;
                    }
                }
                if (popup != null)
                {
                    // Find the child window.
                    child = FindFocusedChild(popup);
                    if (child == null)
                    {
                        popup.DispatchKeyEvent
                            ((KeyName)keysym, xevent.xkey.state, str);
                    }
                    else
                    {
                        child.DispatchKeyEvent
                            ((KeyName)keysym, xevent.xkey.state, str);
                    }
                }
            }
            break;

            case EventType.KeyRelease:
            {
                // Convert the event into a symbol and a string.
                if (keyBuffer == IntPtr.Zero)
                {
                    keyBuffer = Marshal.AllocHGlobal(32);
                }
                keysym = 0;
                int len = Xlib.XLookupString
                              (ref xevent.xkey, keyBuffer, 32,
                              ref keysym, IntPtr.Zero);

                // Dispatch the event to the top-most popup.
                lock (this)
                {
                    if (list.Length > 0)
                    {
                        popup = list[list.Length - 1];
                    }
                    else
                    {
                        popup = null;
                    }
                }
                if (popup != null)
                {
                    // Find the child window.
                    child = FindFocusedChild(popup);
                    if (child == null)
                    {
                        popup.DispatchKeyReleaseEvent
                            ((KeyName)keysym, xevent.xkey.state);
                    }
                    else
                    {
                        child.DispatchKeyReleaseEvent
                            ((KeyName)keysym, xevent.xkey.state);
                    }
                }
            }
            break;

            default:
            {
                // Everything else is handled normally.
                base.DispatchEvent(ref xevent);
            }
            break;
            }
        }
Пример #21
0
	// Remove a popup from the mapped list.
	public void RemovePopup(PopupWindow popup)
			{
				int index;
				lock(this)
				{
					for(index = list.Length - 1; index >= 0; --index)
					{
						if(list[index] == popup)
						{
							// Remove the item from the list.
							PopupWindow[] newList;
							newList = new PopupWindow [list.Length - 1];
							Array.Copy(list, 0, newList, 0, index);
							Array.Copy(list, index + 1, newList, index,
									   list.Length - index - 1);
							list = newList;

							// If this was the entered window, then
							// send it a fake "LeaveNotify" event.
							if(lastChildEntered != null && 
								lastChildEntered.Parent == popup)
							{
								FakeLeave(lastChildEntered);
								lastChildEntered = null;
							}
							if(lastEntered == popup)
							{
								lastEntered = null;
								FakeLeave(popup);
							}

							// If this was the button window, then clear it.
							if(lastButton == popup)
							{
								lastButton = null;
							}

							// If the list is now empty, then ungrab.
							if(list.Length == 0)
							{
								Ungrab();
							}
							return;
						}
					}
				}
			}
Пример #22
0
	// Add an input/output widget to the pending invalidate list.
	internal void AddPendingInvalidate(InputOutputWidget widget)
			{
				widget.nextInvalidate = invalidateList;
				invalidateList = widget;
			}
Пример #23
0
	// Remove an input/output widget from the pending expose list.
	internal void RemovePendingExpose(InputOutputWidget widget)
			{
				InputOutputWidget current, prev;
				current = exposeList;
				prev = null;
				while(current != null && current != widget)
				{
					prev = current;
					current = current.nextExpose;
				}
				if(current != null)
				{
					if(prev != null)
					{
						prev.nextExpose = current.nextExpose;
					}
					else
					{
						exposeList = current.nextExpose;
					}
				}
			}
Пример #24
0
	// Add an input/output widget to the pending expose list.
	internal void AddPendingExpose(InputOutputWidget widget)
			{
				widget.nextExpose = exposeList;
				exposeList = widget;
				pendingExposes = true;
			}
Пример #25
0
	}; // enum AppEvent

	// Handle the next event and return what kind of event it was.
	private AppEvent HandleNextEvent(bool wait)
			{
				try
				{
					IntPtr dpy = Lock();
					XEvent xevent;
					int timeout;

					// Processing any pending invalidates that we have.
					ProcessPendingInvalidates();
	
					// Flush any requests that are in the outgoing queue.
					Xlib.XFlush(dpy);
	
					// Process "Quit".
					if(quit)
					{
						return AppEvent.Quit;
					}

					// Process events that are already in the queue.
					// It is important that this be done before processing
					// short period timeouts or the events may never get
					// processed at all.
					if(Xlib.XEventsQueued
							(dpy, 2 /* QueuedAfterFlush */) != 0)
					{
						// Read the next event and dispatch it.
						Xlib.XNextEvent(dpy, out xevent);
						Unlock();
						try
						{
							DispatchEvent(ref xevent);
							return AppEvent.Regular;
						}
						finally
						{
							dpy = Lock();
						}
					}

					// Do we have pending expose events to process?
					if(pendingExposes)
					{
						// Process the pending expose events.
						InputOutputWidget widget;
						while(exposeList != null)
						{
							widget = exposeList;
							exposeList = exposeList.nextExpose;
							Unlock();
							try
							{
								widget.Expose();
							}
							finally
							{
								dpy = Lock();
							}
						}
						pendingExposes = false;
						return AppEvent.Regular;
					}
					else
					{
						// Wait for the next event.
						if(wait)
						{
							timeout = Timer.GetNextTimeout(this);
						}
						else
						{
							timeout = 0;
						}
						if(timeout < 0)
						{
							// Make sure that we release the display lock
							// before calling "XNextEvent", so that other
							// threads can issue X requests while we are
							// waiting for the next event to occur.
							Unlock();
							try
							{
								Xlib.XNextEvent(dpy, out xevent);
								DispatchEvent(ref xevent);
							}
							finally
							{
								dpy = Lock();
							}
							return AppEvent.Regular;
						}
						else
						{
							Unlock();
							try
							{
								if(Xlib.XNextEventWithTimeout
									(dpy, out xevent, timeout) > 0)
								{
									DispatchEvent(ref xevent);
									return AppEvent.Regular;
								}
							}
							finally
							{
								dpy = Lock();
							}
						}
					}

					// Process timers that need to be activated.
					if(Timer.ActivateTimers(this))
					{
						return AppEvent.Timer;
					}
				}
				finally
				{
					Unlock();
				}

				// If we get here, then there were no events processed.
				return AppEvent.NoEvent;
			}
Пример #26
0
        }; // enum AppEvent

        // Handle the next event and return what kind of event it was.
        private AppEvent HandleNextEvent(bool wait)
        {
            try
            {
                IntPtr dpy = Lock();
                XEvent xevent;
                int    timeout;

                // Processing any pending invalidates that we have.
                ProcessPendingInvalidates();

                // Flush any requests that are in the outgoing queue.
                Xlib.XFlush(dpy);

                // Process "Quit".
                if (quit)
                {
                    return(AppEvent.Quit);
                }

                // Process events that are already in the queue.
                // It is important that this be done before processing
                // short period timeouts or the events may never get
                // processed at all.
                if (Xlib.XEventsQueued
                        (dpy, 2 /* QueuedAfterFlush */) != 0)
                {
                    // Read the next event and dispatch it.
                    Xlib.XNextEvent(dpy, out xevent);
                    Unlock();
                    try
                    {
                        DispatchEvent(ref xevent);
                        return(AppEvent.Regular);
                    }
                    finally
                    {
                        dpy = Lock();
                    }
                }

                // Do we have pending expose events to process?
                if (pendingExposes)
                {
                    // Process the pending expose events.
                    InputOutputWidget widget;
                    while (exposeList != null)
                    {
                        widget     = exposeList;
                        exposeList = exposeList.nextExpose;
                        Unlock();
                        try
                        {
                            widget.Expose();
                        }
                        finally
                        {
                            dpy = Lock();
                        }
                    }
                    pendingExposes = false;
                    return(AppEvent.Regular);
                }
                else
                {
                    // Wait for the next event.
                    if (wait)
                    {
                        timeout = Timer.GetNextTimeout(this);
                    }
                    else
                    {
                        timeout = 0;
                    }
                    if (timeout < 0)
                    {
                        // Make sure that we release the display lock
                        // before calling "XNextEvent", so that other
                        // threads can issue X requests while we are
                        // waiting for the next event to occur.
                        Unlock();
                        try
                        {
                            timeout = 100;
                            if (Xlib.XNextEventWithTimeout
                                    (dpy, out xevent, timeout) > 0)
                            {
                                DispatchEvent(ref xevent);
                            }
                        }
                        finally
                        {
                            dpy = Lock();
                        }
                        return(AppEvent.Regular);
                    }
                    else
                    {
                        Unlock();
                        try
                        {
                            if (Xlib.XNextEventWithTimeout
                                    (dpy, out xevent, timeout) > 0)
                            {
                                DispatchEvent(ref xevent);
                                return(AppEvent.Regular);
                            }
                        }
                        finally
                        {
                            dpy = Lock();
                        }
                    }
                }

                // Process timers that need to be activated.
                if (Timer.ActivateTimers(this))
                {
                    return(AppEvent.Timer);
                }
            }
            finally
            {
                Unlock();
            }

            // If we get here, then there were no events processed.
            return(AppEvent.NoEvent);
        }
Пример #27
0
	// Send a fake "LeaveNotify" event to a popup window.
	private static void FakeLeave(InputOutputWidget window)
			{
				if(window != null)
				{
					XEvent xevent = new XEvent();
					xevent.xany.type__ =
						(Xlib.Xint)(int)(EventType.LeaveNotify);
					window.DispatchEvent(ref xevent);
				}
			}
Пример #28
0
	private static Screen GetScreen(InputOutputWidget widget)
			{
				if(widget == null)
				{
					throw new ArgumentNullException("widget");
				}
				return widget.screen;
			}
Пример #29
0
	// Change the "lastEntered" and "lastChildEntered" window.
	// The popup is entered before the child and left after.
	private void ChangeEntered(PopupWindow popup, InputOutputWidget child)
			{
				PopupWindow before = null;
				PopupWindow after = null;
				InputOutputWidget childBefore = null;
				InputOutputWidget childAfter = null;
				lock(this)
				{
					if(lastEntered != popup)
					{
						before = lastEntered;
						after = popup;
						lastEntered = popup;
					}
					if(lastChildEntered != child)
					{
						childBefore = lastChildEntered;
						childAfter = child;
						lastChildEntered = child;
					}
				}
				if(before != null)
				{
					if (childBefore != null)
						FakeLeave(childBefore);
					FakeLeave(before);
				}
				if(after != null)
				{
					FakeEnter(after);
					if (childAfter != null)
						FakeEnter(childAfter);
				}
			}
Пример #30
0
	// Remove an input/output widget from the pending invalidate list.
	internal void RemovePendingInvalidate(InputOutputWidget widget)
			{
				InputOutputWidget current, prev;
				current = invalidateList;
				prev = null;
				while(current != null && current != widget)
				{
					prev = current;
					current = current.nextInvalidate;
				}
				if(current != null)
				{
					if(prev != null)
					{
						prev.nextInvalidate = current.nextInvalidate;
					}
					else
					{
						invalidateList = current.nextInvalidate;
					}
				}
			}
Пример #31
0
	// Find the child window that contains a particular mouse position
	private InputOutputWidget FindChild(InputOutputWidget parent, int x, int y)
			{
				if (parent != null)
				{
					foreach(InputOutputWidget child in parent)
					{
						if (child.IsMapped &&
							x - parent.X >= child.X &&
							x - parent.X < (child.X + child.Width) &&
							y - parent.Y >= child.y &&
							y - parent.Y < (child.Y + child.Height))
							return child;
					}
				}
				return null;
			}
	// Flush pending invalidates to the X server.
	internal void FlushInvalidates()
			{
				Region region = invalidateRegion;
				invalidateRegion = null;
				nextInvalidate = null;
				if(region != null)
				{
					// No point redrawing if we are unmapped.
					if(handle != XDrawable.Zero && mapped && AncestorsMapped)
					{
						Invalidate(region);
					}
				}
			}
Пример #33
0
	// Process pending invalidates.
	private void ProcessPendingInvalidates()
			{
				InputOutputWidget current = invalidateList;
				InputOutputWidget next;
				invalidateList = null;
				while(current != null)
				{
					next = current.nextInvalidate;
					current.FlushInvalidates();
					current = next;
				}
			}