// Constructor.
internal Widget(Display dpy, Screen screen,
DrawableKind kind, Widget parent)
: base(dpy, screen, kind)
{
// Set the initial widget properties.
cursor = null;
autoMapChildren = true;
sensitive = true;
// Insert this widget into the widget tree under its parent.
this.parent = parent;
this.topChild = null;
this.nextAbove = null;
if(parent != null)
{
ancestorSensitive =
(parent.sensitive && parent.ancestorSensitive);
nextBelow = parent.topChild;
if(parent.topChild != null)
{
parent.topChild.nextAbove = this;
}
parent.topChild = this;
}
else
{
ancestorSensitive = true;
nextBelow = null;
}
this.eventMask = 0;
}
public static extern int XSendEvent(IntPtr display, IntPtr w, bool propagate, EventMask mask, ref XEvent e);
static extern IntPtr XSelectInput(IntPtr window, IntPtr display, EventMask mask);
internal extern static int XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor, IntPtr timestamp);
public static int XSendEvent(IntPtr display, IntPtr window, bool propagate, EventMask event_mask, ref XEvent send_event)
{
return XSendEvent(display, window, propagate, new IntPtr((int)event_mask), ref send_event);
}
/// <summary>
/// Remove all events of a certain type
/// </summary>
/// <param name="eventMask">
/// Events to remove
/// </param>
public static void Remove(EventMask eventMask)
{
Remove(eventMask, QUERY_EVENTS_MAX);
}
extern public static void XMaskEvent(IntPtr display, EventMask event_mask, ref XEvent e);
internal extern static IntPtr XSelectInput (IntPtr display, IntPtr window, EventMask mask);
/// <summary>
/// Creates an instance attached to a particular named test.
/// </summary>
/// <param name="eventSource">
/// The event source to listen to.
/// </param>
/// <param name="fullyQualifiedTestName">
/// Name of the owning test. Used for diagnostics when these listeners leak (not disposed after a test execution).
/// </param>
/// <param name="captureAllDiagnosticMessages">
/// If true, all messages tagged with Diagnostics are captured (rather than needing to be enabled per-task).
/// </param>
/// <param name="logAction">
/// Action to perform when logging a string. This allows test frameworks to hook into their own logging.
/// Writes to the console if unspecified
/// </param>
/// <param name="eventMask">event mask for controlling which events are enabled/disabled</param>
protected TestEventListenerBase(Events eventSource, string fullyQualifiedTestName, bool captureAllDiagnosticMessages = true, Action <string> logAction = null, EventMask eventMask = null)
: base(eventSource, null, EventLevel.Verbose, captureAllDiagnosticMessages: captureAllDiagnosticMessages, listenDiagnosticMessages: true, eventMask: eventMask)
{
Contract.Requires(eventSource != null);
Contract.Requires(!string.IsNullOrEmpty(fullyQualifiedTestName));
m_owningTestFullyQualifiedName = fullyQualifiedTestName;
m_logAction = logAction;
TestEventListenerBase existingListener = Interlocked.Exchange(ref s_currentTestListener, this);
if (existingListener != null)
{
Interlocked.CompareExchange(ref s_currentTestListener, null, comparand: this);
#pragma warning disable CA2214 // Do not call overridable methods in constructors
AssertTrue(
false,
"A TestEventListener for {0} was not disposed upon completion of the test. This can cause repeated log messages and impact test performance.",
existingListener.m_owningTestFullyQualifiedName);
#pragma warning restore CA2214 // Do not call overridable methods in constructors
}
}
public static extern bool XWindowEvent(Display display, Window w, EventMask event_mask,
ref XEvent event_return);
extern static int XSendEvent(IntPtr display, IntPtr window, bool propagate, EventMask event_mask, ref XClientMessageEvent send_event);
extern static IntPtr XSelectInput(IntPtr window, IntPtr display, EventMask mask);
public static extern Status XGrabPointer(IntPtr display, Window grab_window, bool owner_events, EventMask event_mask,
GrabMode pointer_mode, GrabMode keyboard_mode, Window confine_to, Cursor cursor, ulong time);
public static extern Status XGrabButton(IntPtr display, Button button, KeyButtonMask modifiers, Window grab_window,
bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, Window confine_to, FontCursor cursor);
public static void SelectInput(IntPtr display, IntPtr w, EventMask event_mask);
internal extern static bool XCheckWindowEvent (IntPtr display, IntPtr window, EventMask mask, ref XEvent xevent);
public static extern Status XSendEvent(IntPtr display, IntPtr windoe, bool propagate, EventMask event_mask, ref XClientMessageEvent event_send);
private static extern string XGetICValues (IntPtr xic, string name, out EventMask value, IntPtr terminator);
public static extern Status XCheckWindowEvent(IntPtr display, Window window, EventMask mask, IntPtr event_return);
/// <summary>
/// View all events of a certain type in the queue
/// </summary>
/// <param name="eventMask">Type of events to view</param>
/// <returns>Array of events</returns>
public static SdlEventArgs[] Peek(EventMask eventMask)
{
return Peek(eventMask, QUERY_EVENTS_MAX);
}
public static extern Status XMaskEvent(IntPtr display, EventMask mask, IntPtr event_return);
/// <summary>
/// Retrieve events of a certain type
/// </summary>
/// <param name="eventMask">Event to retrieve</param>
/// <returns>Array containing events</returns>
public static SdlEventArgs[] Retrieve(EventMask eventMask)
{
return Retrieve(eventMask, QUERY_EVENTS_MAX);
}
public static extern bool XCheckMaskEvent(IntPtr display, EventMask mask, IntPtr event_return);
internal static int XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor, IntPtr timestamp)
{
DebugHelper.TraceWriteLine ("XGrabPointer");
return _XGrabPointer(display, window, owner_events, event_mask, pointer_mode, keyboard_mode, confine_to, cursor, timestamp);
}
/// <summary>
/// Gets the channel prototypes for the device.
/// </summary>
public override ICollection <CnlPrototype> GetCnlPrototypes()
{
if (LoadDeviceTemplate() is not DeviceTemplate deviceTemplate)
{
return(null);
}
List <CnlPrototype> cnlPrototypes = new();
int tagNum = 1;
foreach (ElemGroupConfig elemGroupConfig in deviceTemplate.ElemGroups)
{
foreach (ElemConfig elemConfig in elemGroupConfig.Elems)
{
// create channel for element
bool isBool = elemConfig.ElemType == ElemType.Bool;
int eventMask = new EventMask
{
Enabled = true,
DataChange = isBool,
StatusChange = !isBool,
Command = !elemConfig.ReadOnly
}.Value;
cnlPrototypes.Add(new CnlPrototype
{
Active = elemGroupConfig.Active,
Name = elemConfig.Name,
CnlTypeID = elemConfig.ReadOnly ? CnlTypeID.Input : CnlTypeID.InputOutput,
TagNum = string.IsNullOrEmpty(elemConfig.TagCode) ? tagNum : null,
TagCode = elemConfig.TagCode,
FormatCode = isBool
? FormatCode.OffOn
: elemConfig.IsBitMask ? FormatCode.X : null,
EventMask = eventMask
});
// create channels for bit mask
if (elemConfig.IsBitMask && elemConfig.ElemType != ElemType.Bool)
{
eventMask = new EventMask
{
Enabled = true,
DataChange = true,
Command = !elemConfig.ReadOnly
}.Value;
for (int bit = 0, bitCnt = ModbusUtils.GetDataLength(elemConfig.ElemType) * 8;
bit < bitCnt; bit++)
{
cnlPrototypes.Add(new CnlPrototype
{
Active = elemGroupConfig.Active,
Name = elemConfig.Name + "[" + bit + "]",
CnlTypeID = elemConfig.ReadOnly ? CnlTypeID.Calculated : CnlTypeID.CalculatedOutput,
FormatCode = FormatCode.OffOn,
FormulaEnabled = true,
InFormula = $"GetBit(DataRel({-bit - 1}), {bit})",
OutFormula = elemConfig.ReadOnly ? null : $"SetBit(DataRel({-bit - 1}), {bit}, Cmd)",
EventMask = eventMask
});
}
}
tagNum++;
}
}
// create channels for commands
int cmdEventMask = new EventMask {
Enabled = true, Command = true
}.Value;
foreach (CmdConfig cmdConfig in deviceTemplate.Cmds)
{
cnlPrototypes.Add(new CnlPrototype
{
Name = cmdConfig.Name,
CnlTypeID = CnlTypeID.Output,
TagNum = string.IsNullOrEmpty(cmdConfig.CmdCode) ? cmdConfig.CmdNum : null,
TagCode = cmdConfig.CmdCode,
FormatCode = cmdConfig.DataBlock == DataBlock.Coils && !cmdConfig.Multiple ?
FormatCode.OffOn : null,
EventMask = cmdEventMask
});
}
return(cnlPrototypes);
}
internal static extern void SelectInput(Display display, Window w, EventMask event_mask);
private void __BuildControl__control21(EventMask __ctrl)
{
__ctrl.ShowMask = (true);
__ctrl.Msg = ("正在登录");
}
public static extern Status XChangeActivePointerGrab(IntPtr display, EventMask event_mask, Cursor cursor, ulong time);
/// <summary>
/// Remove all events of a certain type
/// </summary>
/// <param name="eventMask">
/// Events to remove
/// </param>
public static void Remove(EventMask eventMask)
{
Remove(eventMask, QUERY_EVENTS_MAX);
}
private extern static IntPtr XSelectInput (IntPtr window, IntPtr display, EventMask mask);
/// <summary>
/// Retrieve events of a certain type
/// </summary>
/// <param name="eventMask">Event to retrieve</param>
/// <returns>Array containing events</returns>
public static SdlEventArgs[] Retrieve(EventMask eventMask)
{
return(Retrieve(eventMask, QUERY_EVENTS_MAX));
}
public static bool CheckMaskEvent(IntPtr display, EventMask event_mask, ref XEvent event_return);
/// <summary>
/// View all events of a certain type in the queue
/// </summary>
/// <param name="eventMask">Type of events to view</param>
/// <returns>Array of events</returns>
public static SdlEventArgs[] Peek(EventMask eventMask)
{
return(Peek(eventMask, QUERY_EVENTS_MAX));
}
internal extern static bool XCheckMaskEvent (IntPtr display, EventMask mask, ref XEvent xevent);
public ConsoleEventListener(Events eventSource, DateTime baseTime, WarningMapper warningMapper = null, EventLevel level = EventLevel.Verbose, bool captureAllDiagnosticMessages = false, TimeDisplay timeDisplay = TimeDisplay.None, EventMask eventMask = null, DisabledDueToDiskWriteFailureEventHandler onDisabledDueToDiskWriteFailure = null, bool listenDiagnosticMessages = false, bool useCustomPipDescription = false)
: base(eventSource, baseTime, warningMapper, level, captureAllDiagnosticMessages, timeDisplay, eventMask, onDisabledDueToDiskWriteFailure, listenDiagnosticMessages, useCustomPipDescription)
{
}
internal extern static int XSendEvent (IntPtr display, IntPtr window, bool propagate, EventMask event_mask, ref XEvent send_event);
public extern static int XGrabButton(IntPtr display,
int button, uint modifiers, Window grab_window,
Bool owner_events, EventMask event_mask,
GrabMode pointer_mode, GrabMode keyboard_mode,
Window confine_to, Cursor cursor);
void CreateXicForWindow (IntPtr window)
{
IntPtr xic = CreateXic (window, xim);
xic_table [(long) window] = xic;
if (xic == IntPtr.Zero)
Console.Error.WriteLine ("Could not get XIC");
else {
if (XGetICValues (xic, "filterEvents", out xic_event_mask, IntPtr.Zero) != null)
Console.Error.WriteLine ("Could not get XIC values");
EventMask mask = EventMask.ExposureMask | EventMask.KeyPressMask | EventMask.FocusChangeMask;
if ((xic_event_mask | mask) == xic_event_mask) {
xic_event_mask |= mask;
lock (XlibLock) {
XplatUIX11.XSelectInput(display, window, new IntPtr ((int) xic_event_mask));
}
}
}
}
public extern static Bool XCheckWindowEvent(Display display, Window w, EventMask event_mask, ref XEvent event_return);
/// <summary>
/// check to se if a certain kind of event is queued
/// </summary>
/// <param name="eventMask">Mask for event to check for</param>
/// <returns>If event is queued, then method returns true</returns>
public static bool IsEventQueued(EventMask eventMask)
{
SdlEventArgs[] eventArray = Peek(eventMask, QUERY_EVENTS_MAX);
if (eventArray.Length > 0)
{
return true;
}
else
{
return false;
}
}
/// <nodoc/>
public TestEventListener(Events eventSource, string fullyQualifiedTestName, bool captureAllDiagnosticMessages = true, Action <string> logAction = null, EventMask eventMask = null)
: base(eventSource, fullyQualifiedTestName, captureAllDiagnosticMessages, logAction, eventMask)
{
}
/// <summary>
/// Returns an array of events in the event queue.
/// </summary>
/// <param name="eventMask">Mask for event that will be removed from queue</param>
/// <param name="numberOfEvents">Number of events to remove</param>
public static void Remove(EventMask eventMask, int numberOfEvents)
{
Sdl.SDL_Event[] events = new Sdl.SDL_Event[numberOfEvents];
Sdl.SDL_PumpEvents();
int result =
Sdl.SDL_PeepEvents(
events,
events.Length,
Sdl.SDL_GETEVENT,
(int)eventMask);
if (result == (int)SdlFlag.Error)
{
throw SdlException.Generate();
}
}
public static int XSendEvent(IntPtr display, IntPtr window, bool propagate, EventMask event_mask, ref XEvent send_event)
{
return(Functions.XSendEvent(display, window, propagate, new IntPtr((int)event_mask), ref send_event));
}
/// <summary>
/// Retrieve events of a certain type
/// </summary>
/// <param name="eventMask">Event to retrieve</param>
/// <param name="numberOfEvents">Number of events to retrieve</param>
/// <returns>Array containing events</returns>
public static SdlEventArgs[] Retrieve(EventMask eventMask, int numberOfEvents)
{
Sdl.SDL_PumpEvents();
Sdl.SDL_Event[] events = new Sdl.SDL_Event[numberOfEvents];
int result = Sdl.SDL_PeepEvents(
events,
events.Length,
Sdl.SDL_GETEVENT,
(int)eventMask
);
if (result == (int)SdlFlag.Error)
{
throw SdlException.Generate();
}
SdlEventArgs[] eventsArray = new SdlEventArgs[result];
for (int i = 0; i < eventsArray.Length; i++)
{
if (events[i].type == (byte)EventTypes.UserEvent)
{
eventsArray[i] = (UserEventArgs)userEvents[events[i].user.code];
userEvents.Remove(events[i].user.code);
}
else
{
eventsArray[i] = SdlEventArgs.CreateEventArgs(events[i]);
}
}
return eventsArray;
}
public static int XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor, IntPtr timestamp);
public extern static int XGrabButton(IntPtr display,
int button, uint modifiers, Window grab_window,
Bool owner_events, EventMask event_mask,
GrabMode pointer_mode, GrabMode keyboard_mode,
Window confine_to, Cursor cursor);
public static int XGrabButton(IntPtr display, int button, uint modifiers, IntPtr grab_window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor);
public extern static Bool XCheckWindowEvent(Display display, Window w, EventMask event_mask, ref XEvent event_return);
public static int XChangeActivePointerGrab(IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time);
internal static int XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time)
{
DebugHelper.TraceWriteLine ("XChangeActivePointerGrab");
return _XChangeActivePointerGrab (display, event_mask, cursor, time);
}
public static void XMaskEvent(IntPtr display, EventMask event_mask, ref XEvent e);
internal extern static int XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time);
public static bool XWindowEvent(IntPtr display, IntPtr w, EventMask event_mask, ref XEvent event_return);
internal static extern bool CheckMaskEvent(Display display, EventMask event_mask, ref XEvent event_return);
extern public static void XSelectInput(IntPtr x11display, IntPtr x11window, EventMask eventMask);
static extern int XSendEvent(IntPtr display, IntPtr window, bool propagate, EventMask event_mask, ref XClientMessageEvent send_event);
private static extern bool WFWaitSystemEvent(IntPtr hServer, EventMask eventMask, out EventMask pEventFlags);
