// Dispatch an event to this widget.
internal override void DispatchEvent(ref XEvent xevent)
{
ButtonName button;
XTime time;
switch((EventType)(xevent.xany.type__))
{
case EventType.ButtonPress:
{
// Process button events.
button = xevent.xbutton.button;
time = xevent.xbutton.time;
if(lastClickButton == button &&
lastClickTime != XTime.CurrentTime &&
(time - lastClickTime) < 500)
{
OnButtonDoubleClick(xevent.xbutton.x,
xevent.xbutton.y, button,
xevent.xbutton.state);
time = XTime.CurrentTime;
}
else
{
OnButtonPress(xevent.xbutton.x,
xevent.xbutton.y, button,
xevent.xbutton.state);
}
lastClickTime = time;
lastClickButton = button;
}
break;
case EventType.ButtonRelease:
{
// Dispatch a button release event.
button = xevent.xbutton.button;
OnButtonRelease(xevent.xbutton.x,
xevent.xbutton.y, button,
xevent.xbutton.state);
}
break;
case EventType.MotionNotify:
{
// Dispatch a pointer motion event.
OnPointerMotion(xevent.xmotion.x,
xevent.xmotion.y,
xevent.xmotion.state);
}
break;
case EventType.EnterNotify:
{
// Dispatch a widget enter event.
Widget child = dpy.handleMap
[xevent.xcrossing.subwindow];
OnEnter(child,
xevent.xcrossing.x,
xevent.xcrossing.y,
xevent.xcrossing.state,
xevent.xcrossing.mode,
xevent.xcrossing.detail);
}
break;
case EventType.LeaveNotify:
{
// Dispatch a widget leave event.
Widget child = dpy.handleMap
[xevent.xcrossing.subwindow];
OnLeave(child,
xevent.xcrossing.x,
xevent.xcrossing.y,
xevent.xcrossing.state,
xevent.xcrossing.mode,
xevent.xcrossing.detail);
}
break;
}
}
// Dispatch an event to this widget.
internal override void DispatchEvent(ref XEvent xevent)
{
IntPtr display;
XWindow child;
if (xevent.type == Xsharp.Events.EventType.MapRequest)
{
// This may be notification of a new window
// that we need to take control of.
try
{
display = dpy.Lock();
child = xevent.xmaprequest.window;
if(WantThisWindow(display, child))
{
// This is the top-level child window that
// we have been waiting for.
XWindowChanges wc = new XWindowChanges();
wc.width = embedParent.Width;
wc.height = embedParent.Height;
wc.border_width = 0;
Xlib.XConfigureWindow
(display, child,
(int)(ConfigureWindowMask.CWWidth |
ConfigureWindowMask.CWHeight |
ConfigureWindowMask.CWBorderWidth),
ref wc);
Xlib.XReparentWindow
(display, child,
embedParent.GetWidgetHandle(), 0, 0);
Xlib.XMapWindow(display, child);
embedParent.child = child;
}
else
{
// We don't want this window, or we already
// know about it, so replay the map request.
Xlib.XMapWindow(display, child);
}
}
finally
{
dpy.Unlock();
}
}
else if (xevent.type == Xsharp.Events.EventType.ConfigureRequest)
{
// Replay the configure event direct to the X server.
XWindowChanges wc = new XWindowChanges();
wc.x = xevent.xconfigurerequest.x;
wc.y = xevent.xconfigurerequest.y;
wc.width = xevent.xconfigurerequest.width;
wc.height = xevent.xconfigurerequest.height;
wc.border_width = xevent.xconfigurerequest.border_width;
wc.sibling = xevent.xconfigurerequest.above;
wc.stack_mode = xevent.xconfigurerequest.detail;
try
{
display = dpy.Lock();
Xlib.XConfigureWindow
(display,
xevent.xconfigurerequest.window,
xevent.xconfigurerequest.value_mask, ref wc);
}
finally
{
dpy.Unlock();
}
}
base.DispatchEvent(ref xevent);
}
/// Dispatch an event to this widget.
internal override void DispatchEvent(ref XEvent xevent)
{
if(((EventType)(xevent.xany.type__)) ==
EventType.PropertyNotify &&
xevent.xproperty.atom == resourceManager)
{
// The "RESOURCE_MANAGER" property has changed.
IntPtr resptr = Xlib.XSharpGetResources
(dpy.dpy, GetWidgetHandle());
if(resptr != IntPtr.Zero)
{
resources = Marshal.PtrToStringAnsi(resptr);
Xlib.XSharpFreeResources(resptr);
}
else
{
resources = null;
}
if(ResourcesChanged != null)
{
ResourcesChanged(this, EventArgs.Empty);
}
}
}
extern public static int XNextEventWithTimeout (IntPtr display, out XEvent xevent, int timeout);
// Dispatch an event to this widget.
internal override void DispatchEvent(ref XEvent xevent)
{
if (xevent.type == Xsharp.Events.EventType.DestroyNotify &&
xevent.xdestroywindow.window == child)
{
// The child window has been destroyed.
ChildDestroyed();
}
base.DispatchEvent(ref xevent);
}
protected void SendBeginInvoke(IntPtr i_gch)
{
XEvent xevent = new XEvent();
xevent.xany.type = (int)(EventType.ClientMessage);
xevent.xany.window = GetWidgetHandle();
xevent.xclient.format = 32;
xevent.xclient.setl(0,(int)i_gch);
try
{
IntPtr display = dpy.Lock();
xevent.xclient.message_type = Xlib.XInternAtom
(display, "INTERNAL_BEGIN_INVOKE", XBool.False);
Xlib.XSendEvent (display, GetWidgetHandle(),
XBool.False, (int)(EventMask.NoEventMask), ref xevent);
Xlib.XFlush(display);
}
finally
{
dpy.Unlock();
}
}
extern public static XStatus XSendEvent (IntPtr display, XWindow w, XBool propagate, int event_mask, ref XEvent event_send);
// 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);
}
}
// 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;
}
}
// Dispatch an event that occurred on this display. We currently
// have the display lock.
private void DispatchEvent(ref XEvent xevent)
{
// Find the widget that should process the event.
Widget widget = handleMap[xevent.xany.window];
// Record the time at which the event occurred. We need
// this to process keyboard and pointer grabs correctly.
switch((EventType)(xevent.xany.type__))
{
case EventType.KeyPress:
case EventType.KeyRelease:
{
knownEventTime = xevent.xkey.time;
if(widget != null && !(widget.Parent is RootWindow))
{
// KeyPress/KeyRelease events must be dispatched
// via the top-level window, never via children.
while(widget.Parent != null &&
!(widget.Parent is RootWindow))
{
widget = widget.Parent;
}
}
}
break;
case EventType.ButtonPress:
case EventType.ButtonRelease:
{
knownEventTime = xevent.xbutton.time;
if (((xevent.xbutton.button == ButtonName.Button4) ||
(xevent.xbutton.button == ButtonName.Button5)) &&
((widget != null) && !(widget.Parent is RootWindow)))
{
// Mousewheel events must be dispatched
// via the top-level window, never via children.
while (widget.Parent != null &&
!(widget.Parent is RootWindow))
{
widget = widget.Parent;
}
}
}
break;
case EventType.MotionNotify:
{
knownEventTime = xevent.xmotion.time;
}
break;
case EventType.EnterNotify:
case EventType.LeaveNotify:
{
knownEventTime = xevent.xcrossing.time;
}
break;
case EventType.PropertyNotify:
{
knownEventTime = xevent.xproperty.time;
}
break;
case EventType.SelectionClear:
{
knownEventTime = xevent.xselectionclear.time;
}
break;
case EventType.SelectionNotify:
{
knownEventTime = xevent.xselection.time;
}
break;
case EventType.SelectionRequest:
{
knownEventTime = xevent.xselectionrequest.time;
}
break;
default:
{
// We don't have a time value for this event.
knownEventTime = XTime.CurrentTime;
}
break;
}
// Dispatch the event to the widget.
if(widget != null)
{
widget.DispatchEvent(ref xevent);
}
}
// Dispatch an event to this widget.
internal override void DispatchEvent(ref XEvent xevent)
{
ButtonName button;
XTime time;
switch((EventType)(xevent.xany.type__))
{
case EventType.ButtonPress:
{
// If we have a passive grab in force, then raise
// this window and replay the event normally.
if((flags & CaptionFlags.Grabbed) != 0)
{
Raise();
try
{
IntPtr display = dpy.Lock();
Xlib.XAllowEvents
(display, 2 /* ReplayPointer */,
dpy.knownEventTime);
}
finally
{
dpy.Unlock();
}
return;
}
// Process button events.
button = xevent.xbutton.button;
time = xevent.xbutton.time;
if(lastClickButton == button &&
lastClickTime != XTime.CurrentTime &&
(time - lastClickTime) < 500)
{
OnButtonDoubleClick(xevent.xbutton.x,
xevent.xbutton.y,
xevent.xbutton.x_root,
xevent.xbutton.y_root,
button, xevent.xbutton.state);
time = XTime.CurrentTime;
}
else
{
OnButtonPress(xevent.xbutton.x,
xevent.xbutton.y,
xevent.xbutton.x_root,
xevent.xbutton.y_root,
button, xevent.xbutton.state);
}
lastClickTime = time;
lastClickButton = button;
}
break;
case EventType.ButtonRelease:
{
// Dispatch a button release event.
button = xevent.xbutton.button;
OnButtonRelease(xevent.xbutton.x,
xevent.xbutton.y,
xevent.xbutton.x_root,
xevent.xbutton.y_root,
button, xevent.xbutton.state);
}
break;
case EventType.MotionNotify:
{
// Dispatch a pointer motion event.
OnPointerMotion(xevent.xmotion.x,
xevent.xmotion.y,
xevent.xmotion.x_root,
xevent.xmotion.y_root,
xevent.xmotion.state);
}
break;
default:
{
base.DispatchEvent(ref xevent);
}
break;
}
}
// Send a maximize or restore message to the window manager.
private void SendMaximizeMessage
(IntPtr display, XWindow handle, bool maximize)
{
XEvent xevent = new XEvent();
xevent.xany.type = (int)(Xsharp.Events.EventType.ClientMessage);
xevent.xany.window = handle;
xevent.xclient.message_type = Xlib.XInternAtom
(display, "_NET_WM_STATE", XBool.False);
xevent.xclient.format = 32;
if(maximize)
{
xevent.xclient.setl(0, 1 /* _NET_WM_STATE_ADD */ );
}
else
{
xevent.xclient.setl(0, 0 /* _NET_WM_STATE_REMOVE */ );
}
XAtom atom1 = Xlib.XInternAtom
(display, "_NET_WM_STATE_MAXIMIZED_VERT", XBool.False);
XAtom atom2 = Xlib.XInternAtom
(display, "_NET_WM_STATE_MAXIMIZED_HORZ", XBool.False);
xevent.xclient.setl(1, (int)atom1);
xevent.xclient.setl(2, (int)atom2);
Xlib.XSendEvent
(display, screen.RootWindow.GetWidgetHandle(),
XBool.False, (int)(EventMask.NoEventMask),
ref xevent);
}
// Dispatch an event to this widget.
internal override void DispatchEvent(ref XEvent xevent)
{
XKeySym keysym;
Widget widget;
InputOnlyWidget io;
Xlib.Xlong[] data;
switch((Xsharp.Events.EventType)(xevent.xany.type__))
{
case Xsharp.Events.EventType.ClientMessage:
{
// Handle messages from the window manager.
if(xevent.xclient.message_type == dpy.wmProtocols)
{
if(xevent.xclient.l(0) == (int)(dpy.wmDeleteWindow))
{
// User wants the window to close.
Close();
}
else if(xevent.xclient.l(0) == (int)(dpy.wmTakeFocus))
{
// We were given the primary input focus.
PrimaryFocusIn();
}
else if(xevent.xclient.l(0) == (int)(dpy.wmContextHelp))
{
// The user pressed the "help" button.
OnHelp();
}
else if(xevent.xclient.l(0) == (int)(dpy.wmPing))
{
// The window manager has pinged us to see
// if we are still responding or are dead.
// We send the message straight back to the WM.
try
{
IntPtr display = dpy.Lock();
xevent.xany.window = screen.RootWindow.GetWidgetHandle();
Xlib.XSendEvent
(display, xevent.xany.window,
XBool.False,
(int)(EventMask.NoEventMask),
ref xevent);
}
finally
{
dpy.Unlock();
}
}
}
}
break;
case Xsharp.Events.EventType.PropertyNotify:
{
// Handle a property change notification.
if(xevent.xproperty.atom == dpy.wmState)
{
// The "WM_STATE" property has changed.
if(xevent.xproperty.state == 0)
{
// New value for the window state.
data = GetWindowProperty(dpy.wmState);
if(data.Length >= 1 && data[0] == (Xlib.Xlong)3)
{
// The window is now in the iconic state.
if(!iconic)
{
iconic = true;
OnIconicStateChanged(true);
}
}
else
{
// The window is now in the normal state.
if(iconic)
{
iconic = false;
OnIconicStateChanged(false);
}
}
}
else
{
// Property removed, so it is "normal" now.
if(iconic)
{
iconic = false;
OnIconicStateChanged(false);
}
}
}
else if(xevent.xproperty.atom == dpy.wmNetState)
{
// The "_NET_WM_STATE" property has changed.
if(xevent.xproperty.state == 0)
{
// New value: look for maximized state atoms.
data = GetWindowProperty(dpy.wmNetState);
if(ContainsMaximizedAtom(data))
{
// The window is now maximized.
if(!maximized)
{
maximized = true;
OnMaximizedStateChanged(true);
}
}
else
{
// The window has been restored.
if(maximized)
{
maximized = false;
OnMaximizedStateChanged(false);
}
}
}
else
{
// Value removed, so not maximized any more.
if(maximized)
{
maximized = false;
OnMaximizedStateChanged(false);
}
}
}
else if(xevent.xclient.message_type == dpy.internalBeginInvoke)
{
OnBeginInvokeMessage((IntPtr)xevent.xclient.l(0));
}
}
break;
case Xsharp.Events.EventType.FocusIn:
{
// This window has received the focus.
PrimaryFocusIn();
}
break;
case Xsharp.Events.EventType.FocusOut:
{
// This window has lost the focus.
if(hasPrimaryFocus)
{
hasPrimaryFocus = false;
if(focusWidget != null)
{
focusWidget.DispatchFocusOut(null);
}
OnPrimaryFocusOut();
}
}
break;
case Xsharp.Events.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;
}
// Special case: check for Alt+F4 to close the window.
// Some window managers trap Alt+F4 themselves, but not
// all. People who are used to System.Windows.Forms
// under Windows expect Alt+F4 to close the window,
// irrespective of what key the window manager uses.
//
// Note: this check is not foolproof. The window
// manager or the kernel may have redirected Alt+F4
// for some other purpose (e.g. switching between
// virtual consoles). On such systems, there is
// nothing that we can do to get the key event and
// this code will never be called.
//
if((((KeyName)keysym) == KeyName.XK_F4 ||
((KeyName)keysym) == KeyName.XK_KP_F4) &&
(xevent.xkey.state & ModifierMask.Mod1Mask) != 0)
{
Close();
break;
}
// If we have an MDI client, then give it a chance
// to process the keypress just in case it is
// something like Ctrl+F4 or Ctrl+Tab.
if(mdiClient != null)
{
if(mdiClient.DispatchKeyEvent
((KeyName)keysym, xevent.xkey.state, str))
{
break;
}
}
// Dispatch the event.
widget = focusWidget;
while(widget != null)
{
io = (widget as InputOnlyWidget);
if(io != null)
{
if(io.DispatchKeyEvent
((KeyName)keysym, xevent.xkey.state, str))
{
break;
}
}
if(widget == this)
{
break;
}
widget = widget.Parent;
}
}
break;
case Xsharp.Events.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.
widget = focusWidget;
while(widget != null)
{
io = (widget as InputOnlyWidget);
if(io != null)
{
if(io.DispatchKeyReleaseEvent
((KeyName)keysym, xevent.xkey.state))
{
break;
}
}
if(widget == this)
{
break;
}
widget = widget.Parent;
}
}
break;
case Xsharp.Events.EventType.ButtonPress:
{
if ((xevent.xbutton.button == ButtonName.Button4) ||
(xevent.xbutton.button == ButtonName.Button5))
return;
}
break;
case Xsharp.Events.EventType.ButtonRelease:
{
// Handle mouse wheel events.
// Sanity check
if ((xevent.xbutton.button != ButtonName.Button4) &&
(xevent.xbutton.button != ButtonName.Button5))
break;
// Dispatch the event.
widget = focusWidget;
while(widget != null)
{
io = (widget as InputOnlyWidget);
if (io != null)
{
if (io.DispatchWheelEvent (ref xevent))
{
return;
}
}
if (widget == this)
{
break;
}
widget = widget.Parent;
}
}
break;
case Xsharp.Events.EventType.ConfigureNotify:
{
// The window manager may have caused us to move/resize.
if(xevent.xconfigure.window != xevent.window)
{
// SubstructureNotify - not interesting to us.
break;
}
if(Parent is CaptionWidget)
{
// Ignore configure events if we are an MDI child.
break;
}
if(xevent.xconfigure.width != width ||
xevent.xconfigure.height != height ||
expectedWidth != -1)
{
// The size has been changed by the window manager.
if(expectedWidth == -1)
{
// Resize from the window manager, not us.
width = xevent.xconfigure.width;
height = xevent.xconfigure.height;
}
else if(expectedWidth == xevent.xconfigure.width &&
expectedHeight == xevent.xconfigure.height)
{
// This is the size that we were expecting.
// Further ConfigureNotify's will be from
// the window manager instead of from us.
expectedWidth = -1;
expectedHeight = -1;
}
if(resizeTimer == null)
{
resizeTimer = new Timer
(new TimerCallback(PerformResize), null,
0, -1);
}
}
if(xevent.send_event || !reparented)
{
// The window manager moved us to a new position.
if(x != xevent.xconfigure.x ||
y != xevent.xconfigure.y)
{
x = xevent.xconfigure.x;
y = xevent.xconfigure.y;
OnMoveResize(x, y, width, height);
}
}
}
break;
case Xsharp.Events.EventType.ReparentNotify:
{
// We may have been reparented by the window manager.
if(xevent.xreparent.window != (XWindow)handle)
{
// SubstructureNotify - not interesting to us.
break;
}
if(xevent.xreparent.parent !=
(XWindow)(screen.RootWindow.handle))
{
// Reparented by the window manager.
reparented = true;
}
else
{
// Window manager crashed: we are back on the root.
reparented = false;
x = xevent.xreparent.x;
y = xevent.xreparent.y;
OnMoveResize(x, y, width, height);
}
}
break;
case Xsharp.Events.EventType.MapNotify:
{
// The window manager mapped us to the screen.
if(Parent is CaptionWidget)
{
break;
}
if(iconic)
{
iconic = false;
OnIconicStateChanged(false);
}
if(!mapped)
{
mapped = true;
OnMapStateChanged();
}
}
break;
case Xsharp.Events.EventType.UnmapNotify:
{
// We were unmapped from the screen. If "mapped"
// is true, then we are being iconified by the window
// manager. Otherwise, we asked to be withdrawn.
if(Parent is CaptionWidget)
{
break;
}
if(!iconic && mapped)
{
iconic = true;
OnIconicStateChanged(true);
}
}
break;
}
base.DispatchEvent(ref xevent);
}
// Dispatch an event to this widget.
internal override void DispatchEvent(ref XEvent xevent)
{
switch((EventType)(xevent.xany.type__))
{
case EventType.SelectionClear:
{
// We have lost ownership of the selection.
formats = null;
values = null;
}
break;
case EventType.SelectionRequest:
{
// Bail out if we received a request from ourselves!
if(xevent.xselectionrequest.requestor ==
GetWidgetHandle())
{
break;
}
// Build the SelectionNotify event for the reply.
XEvent response = new XEvent();
response.xany.type = (int)(EventType.SelectionNotify);
response.xselection.requestor =
xevent.xselectionrequest.requestor;
response.xselection.selection =
xevent.xselectionrequest.selection;
response.xselection.target =
xevent.xselectionrequest.target;
response.xselection.property = XAtom.Zero;
response.xselection.time =
xevent.xselectionrequest.time;
// TODO
// Transmit the response back to the requestor.
try
{
IntPtr display = dpy.Lock();
Xlib.XSendEvent
(display,
xevent.xselectionrequest.requestor,
XBool.False,
(int)(EventMask.NoEventMask),
ref response);
}
finally
{
dpy.Unlock();
}
}
break;
}
base.DispatchEvent(ref xevent);
}
// Dispatch a mouse wheel event to this widget from the top-level window.
internal bool DispatchWheelEvent(ref XEvent xevent)
{
if(FullSensitive)
{
return OnButtonWheel (xevent.xbutton.x, xevent.xbutton.y,
xevent.xbutton.button, xevent.xbutton.state,
(xevent.xbutton.button == ButtonName.Button4 ? 120 : -120));
}
else
{
return false;
}
}
extern public static int XNextEvent(IntPtr display, out XEvent xevent);
// Dispatch an event to this widget.
internal override void DispatchEvent(ref XEvent xevent)
{
switch((EventType)(xevent.xany.type__))
{
case EventType.Expose:
case EventType.GraphicsExpose:
{
// Add the area to the expose region.
if(exposeRegion == null)
{
// This is the first rectangle in an expose.
exposeRegion = new Region
((int)(xevent.xexpose.x__),
(int)(xevent.xexpose.y__),
(int)(xevent.xexpose.width__),
(int)(xevent.xexpose.height__));
// Queue this widget for later repainting.
// We don't do it now or the system will be
// very slow during opaque window drags.
dpy.AddPendingExpose(this);
}
else
{
// This is an extra rectangle in an expose.
exposeRegion.Union
((int)(xevent.xexpose.x__),
(int)(xevent.xexpose.y__),
(int)(xevent.xexpose.width__),
(int)(xevent.xexpose.height__));
}
}
break;
case Xsharp.Events.EventType.ClientMessage:
{
if(xevent.xclient.message_type == dpy.internalBeginInvoke)
{
OnBeginInvokeMessage((IntPtr)xevent.xclient.l(0));
}
}
break;
}
base.DispatchEvent(ref xevent);
}
} // class WidgetEnumerator
/// Dispatch an event to this widget.
internal virtual void DispatchEvent(ref XEvent xevent)
{
// Nothing to do here: overridden by subclasses.
}