public void EnqueueUnlocked (XEvent xevent)
{
switch (xevent.type) {
case XEventName.KeyPress:
case XEventName.KeyRelease:
case XEventName.ButtonPress:
case XEventName.ButtonRelease:
NeedDispatchIdle = true;
break;
case XEventName.MotionNotify:
if (xqueue.Count > 0) {
XEvent peek = xqueue.Peek ();
if (peek.AnyEvent.type == XEventName.MotionNotify)
return; // we've already got a pending motion notify.
}
// otherwise fall through and enqueue
// the event.
break;
}
xqueue.Enqueue (xevent);
// wake up any thread blocking in DequeueUnlocked
Monitor.PulseAll (lockobj);
}
System.Windows.Forms.Keys StringToWFKey(XEvent Event)
{
Dummy.Remove(0, Dummy.Length);
Dummy.Append(" "); // HACK: Somehow necessary
Event.KeyEvent.state = 16; // Repair any shifting applied by control
if(Xlib.XLookupString(ref Event, Dummy, 10, IntPtr.Zero, IntPtr.Zero) != 0)
{
string Lookup = Dummy.ToString();
if(Dummy.Length == 1 && char.IsLetterOrDigit(Dummy[0]))
Lookup = Dummy[0].ToString().ToUpper();
if(string.IsNullOrEmpty(Lookup.Trim())) return System.Windows.Forms.Keys.None;
try
{
return (System.Windows.Forms.Keys) Enum.Parse(typeof(System.Windows.Forms.Keys), Lookup);
}
catch(ArgumentException)
{
// TODO
Console.Error.WriteLine("Warning, could not look up key: "+Lookup);
return System.Windows.Forms.Keys.None;
}
}
else return System.Windows.Forms.Keys.None;
}
public override void ProcessXEvent(XEvent e)
{
switch ((HostInterfaceEventType)e.Type)
{
case HostInterfaceEventType.GenerateNextIORequest:
if (XEngineFactory.XEngine.Time >= SimulationStopTime)
{
Finished = true;
}
uint streamID = (uint)e.Parameters;
IORequest request = _inputStreams[streamID].GetNextIORequest(this, foldAddress, ignoreUnallocatedReads);
ReceivedRequestCount++;
if (request.Type == IORequestType.Write) //write request in ascii traces
{
ReceivedWriteRequestCount++;
}
else //read request in ascii traces
{
ReceivedReadRequestCount++;
}
if (request.ToBeIgnored)
{
ignoredRequestsCount++;
}
else
{
OnIORequestArrived(streamID);
}
break;
case HostInterfaceEventType.RequestCompletedByDRAM:
IORequest targetRequest = e.Parameters as IORequest;
SendEarlyResponseToHost(targetRequest);
break;
default:
throw new Exception("Unhandled XEvent type");
}
}
private void ProcEvent(XEvent evt)
{
if (evt.type == XEventName.MotionNotify && InputBlocked)
{
HandleMotionEvent(evt.MotionEvent);
}
if (evt.type == XEventName.ButtonPress && InputBlocked)
{
HandleButtonPressEvent(evt.ButtonEvent);
}
else if (evt.type == XEventName.ButtonRelease && InputBlocked)
{
HandleButtonReleaseEvent(evt.ButtonEvent);
}
else if (evt.type == XEventName.KeyPress || evt.type == XEventName.KeyRelease)
{
HandleKeyEvent(evt.KeyEvent);
}
else if (evt.type == XEventName.PropertyNotify && (evt.PropertyEvent.atom == atomGrab || evt.PropertyEvent.atom == atomUngrab))
{
HandleInvokeAtom(evt.PropertyEvent.atom);
}
}
protected virtual void OnMouseButtonRelease(XEvent xevent)
{
MouseButton button = (MouseButton)xevent.ButtonEvent.button;
var mousex = xevent.ButtonEvent.x;
var mousey = xevent.ButtonEvent.y;
if (button == MouseButton.ScrollDown || button == MouseButton.ScrollUp)
{
var delta = button == MouseButton.ScrollUp ? 1 : -1;
if (MouseScroll != null)
{
MouseScroll(this, new XMouseScrollArgs(delta));
}
}
else
{
if (MouseButtonRelease != null)
{
MouseButtonRelease(this, new XMouseButtonReleaseArgs(new Point(mousex, mousey), button));
}
}
}
protected override XEvent Peek()
{
X11Hwnd hwnd = (X11Hwnd)hwnds[0];
XEvent xevent = new XEvent();
xevent.AnyEvent.type = XEventName.Expose;
if (hwnd.PendingExpose)
{
xevent.ExposeEvent.window = hwnd.ClientWindow;
}
else
{
xevent.ExposeEvent.window = hwnd.WholeWindow;
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);
}
System.Windows.Forms.Keys StringToWFKey(XEvent Event)
{
Dummy.Remove(0, Dummy.Length);
Dummy.Append(" "); // HACK: Somehow necessary
Event.KeyEvent.state = 16; // Repair any shifting applied by control
if (Xlib.XLookupString(ref Event, Dummy, 10, IntPtr.Zero, IntPtr.Zero) != 0)
{
string Lookup = Dummy.ToString();
if (Dummy.Length == 1 && char.IsLetterOrDigit(Dummy[0]))
{
Lookup = Dummy[0].ToString().ToUpper();
}
if (string.IsNullOrEmpty(Lookup.Trim()))
{
return(System.Windows.Forms.Keys.None);
}
try
{
return((System.Windows.Forms.Keys)Enum.Parse(typeof(System.Windows.Forms.Keys), Lookup));
}
catch (ArgumentException)
{
// TODO
Console.Error.WriteLine("Warning, could not look up key: " + Lookup);
return(System.Windows.Forms.Keys.None);
}
}
else
{
return(System.Windows.Forms.Keys.None);
}
}
/// 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);
}
}
}
public void EnqueueLocked(XEvent xevent)
{
lock (lqueue) {
lqueue.Enqueue(xevent);
}
}
public WindowResizeTest()
{
t = new Timer();
dpy = new XDisplay(IntPtr.Zero);
s = new XScreen(dpy);
ev = new XEvent(dpy);
pointer = new XPointer(dpy);
gc = new XGC(dpy);
//XShape shape = new XShape(dpy);
//shape.Query();
//Console.WriteLine("Shape Event Type Number = {0}", shape.Type.ToString());
//atom = new XAtom (dpy, "_MAJYK_HINT", false);
// Used to test the XPM function that reads a pixmap from a char**
// pix_data = new string[] {
// "16 16 16 1",
// " c None",
// ". c #323232",
// "+ c #535353",
// "@ c #4A8A8E",
// "# c #DEE2E2",
// "$ c #7E827A",
// "% c #8A9292",
// "& c #D6D6D6",
// "* c #36767E",
// "= c #9E9E9E",
// "- c #FAFAFA",
// "; c #B2B2B2",
// "> c #DEEEEA",
// ", c #464646",
// "' c #5EA2A2",
// ") c #52969A",
// " ",
// " ",
// " --#>>>>>>#-#-; ",
// " -&%')))))=&=&+ ",
// " >;$@*****=;%;+ ",
// " &$$$$$$$$$$$$, ",
// " &;;;;;;;;;;;;+ ",
// " &;;;;;;;;;;;;+ ",
// " #;;;;;;;;;;;;+ ",
// " &;;;;;;;;;;;;+ ",
// " #;;;;;;;;;;;;+ ",
// " #;;;;;;;;;;;;+ ",
// " &;;;;;;;;;;;;+ ",
// " $............. ",
// " ",
// " "
// };
bg_color = new XColor(dpy, "#AAAAAA");
handle_color = new XColor(dpy, "#FF0000");
//bg_color = new XColor(dpy, Color.FromArgb(200, 200, 200));
//handle_color = new XColor(dpy, Color.FromArgb(0, 255, 0));
main_win = new XWindow(dpy, new Rectangle(5, 5, 640, 480), 0, s.BlackPixel(), s.WhitePixel());
main_win.Name = "Window Resize Test";
main_win.SelectInput(XEventMask.KeyPressMask | XEventMask.ExposureMask);
resize_main_win = new XWindow(dpy, main_win, new Rectangle(resize_win_x, resize_win_y, resize_win_width, resize_win_height), 1, s.BlackPixel(), bg_color.Pixel);
resize_top_left_win = new XWindow(dpy, resize_main_win, new Rectangle(0, 0, resize_handle_width, resize_handle_height), 1, s.BlackPixel(), handle_color.Pixel);
resize_top_right_win = new XWindow(dpy, resize_main_win, new Rectangle(0, 0, resize_handle_width, resize_handle_height), 1, s.BlackPixel(), handle_color.Pixel);
resize_bottom_left_win = new XWindow(dpy, resize_main_win, new Rectangle(0, 0, resize_handle_width, resize_handle_height), 1, s.BlackPixel(), handle_color.Pixel);
resize_bottom_right_win = new XWindow(dpy, resize_main_win, new Rectangle(0, 0, resize_handle_width, resize_handle_height), 1, s.BlackPixel(), handle_color.Pixel);
//string foo="MAJYK!";
//resize_main_win.ChangeProperty(atom, atom, 8, PropMode.PropModeReplace, Marshal.StringToHGlobalAnsi(foo), foo.Length);
//int return_type=0;
//int actual_format=0;
//int nitems=0;
//int bytes_return=0;
//IntPtr data = IntPtr.Zero;
//resize_main_win.GetProperty(atom, 0, 2, false, atom, out return_type, out actual_format, out nitems, out bytes_return, out data);
//string z = Marshal.PtrToStringAnsi(data);
//Console.WriteLine("nitems = {0}, z = {1}", nitems, z);
//pix = new XPixmap (dpy);
//if (pix.ReadPixmapFromData (resize_main_win, pix_data)) {
// resize_main_win.SetBackgroundPixmap (pix);
// Console.WriteLine ("pixmap w = {0} | h = {1}", pix.Width.ToString (), pix.Height.ToString ());
//}
resize_main_win.SetBackgroundColor(Color.Gray);
// Test TransientFor
//resize_main_win.SetTransientForHint(main_win);
//Window foo = resize_main_win.GetTransientForHint();
//Console.WriteLine("resize_main_win = {0} | foo.transient_for = {1} | main_win = {2}", resize_main_win.ID.ToString(), foo.ID.ToString(), main_win.ID.ToString());
XEventMask mask = XEventMask.ButtonPressMask | XEventMask.ButtonReleaseMask;
resize_main_win.SelectInput(mask);
resize_top_left_win.SelectInput(mask);
resize_top_right_win.SelectInput(mask);
resize_bottom_left_win.SelectInput(mask);
resize_bottom_right_win.SelectInput(mask);
PlaceHandles();
resize_main_win.MapSubwindows();
main_win.MapSubwindows();
main_win.Map();
ev.KeyPressHandlerEvent += new KeyPressHandler(HandleKeyPress);
ev.MotionNotifyHandlerEvent += new MotionNotifyHandler(HandleMotionNotify);
ev.ButtonPressHandlerEvent += new ButtonPressHandler(HandleButtonPress);
ev.ButtonReleaseHandlerEvent += new ButtonReleaseHandler(HandleButtonRelease);
ev.ExposeHandlerEvent += new ExposeHandler(HandleExpose);
t.Interval = 1000;
t.Enabled = true;
t.Elapsed += new ElapsedEventHandler(UpdateClock);
t.Start();
ev.Loop();
}
protected override XEvent Peek ()
{
X11Hwnd hwnd = (X11Hwnd)hwnds[0];
XEvent xevent = new XEvent ();
xevent.AnyEvent.type = XEventName.ConfigureNotify;
xevent.ConfigureEvent.window = hwnd.ClientWindow;
xevent.ConfigureEvent.x = hwnd.X;
xevent.ConfigureEvent.y = hwnd.Y;
xevent.ConfigureEvent.width = hwnd.Width;
xevent.ConfigureEvent.height = hwnd.Height;
return xevent;
}
public override void ProcessXEvent(XEvent e)
{
if (e.Removed)
{
return;
}
//Just only one xevent: OperationFinished
InternalRequest targetRequest = e.Parameters as InternalRequest;
FlashChipDie targetDie = this.Dies[targetRequest.TargetPageAddress.DieID];
targetDie.CurrentExecutingOperationCount--;
if (targetDie.CurrentExecutingOperationCount == 0)
{
targetDie.Status = DieStatus.Idle;
}
targetDie.Planes[targetRequest.TargetPageAddress.PlaneID].Status = PlaneStatus.Idle;
targetDie.Planes[targetRequest.TargetPageAddress.PlaneID].CurrentExecutingRequest = null;
CurrentExecutingOperationCount--;
if (CurrentExecutingOperationCount == 0)
{
Status = FlashChipStatus.Idle;
totalCommandExecutionPeriod += XEngineFactory.XEngine.Time - ThisRoundExecutionStart;
ThisRoundExecutionFinish = XEngineFactory.XEngine.Time;
}
switch (targetRequest.Type)
{
case InternalRequestType.Read:
this.ReadCount++;
targetDie.Planes[targetRequest.TargetPageAddress.PlaneID].ReadCount++;
targetRequest.ExecutionTime += this.readLatency;
this.Status = FlashChipStatus.Waiting;
//Either a normal read (waiting for read data transfer) or a copyback read (waiting for write execution)
this.CurrentWaitingTransfers++;
if (targetDie.Status == DieStatus.Idle)
{
targetDie.TotalReadExecutionPeriod += readLatency;
}
break;
case InternalRequestType.Write:
this.ProgamCount++;
targetDie.Planes[targetRequest.TargetPageAddress.PlaneID].ProgamCount++;
targetRequest.ExecutionTime += this.programLatency;
if (targetDie.Status == DieStatus.Idle)
{
targetDie.TotalProgramExecutionPeriod += programLatency;
}
break;
case InternalRequestType.Clean:
this.EraseCount++;
targetDie.Planes[targetRequest.TargetPageAddress.PlaneID].EraseCount++;
targetRequest.ExecutionTime += this.eraseLatency;
FlashChipBlock targetBlock = this.Dies[targetRequest.TargetPageAddress.DieID].Planes[targetRequest.TargetPageAddress.PlaneID].Blocks[targetRequest.TargetPageAddress.BlockID];
targetDie.Planes[targetRequest.TargetPageAddress.PlaneID].FreePagesNo += (PageNoPerBlock - targetBlock.FreePageNo);
targetBlock.FreePageNo = PageNoPerBlock;
targetBlock.InvalidPageNo = 0;
targetBlock.LastWrittenPageNo = -1;
targetBlock.EraseCount++;
for (int i = 0; i < PageNoPerBlock; i++)
{
targetBlock.Pages[i].StreamID = FlashChipPage.PG_NOSTREAM;
targetBlock.Pages[i].ValidStatus = FlashChipPage.PG_FREE;
targetBlock.Pages[i].LPN = ulong.MaxValue;
}
#region UpdateFastGCData
targetDie.BlockInfoAbstract[targetBlock.BlockID].FreePageNo += PageNoPerBlock;
targetDie.BlockInfoAbstract[targetBlock.BlockID].InvalidPageNo = 0;
targetDie.BlockInfoAbstract[targetBlock.BlockID].EraseCount++;
#endregion
if (targetDie.Status == DieStatus.Idle)
{
targetDie.TotalEraseExecutionPeriod += eraseLatency;
}
break;
default:
break;
}
OnInternalRequestServiced(targetRequest);
}
void HandleXEvent (XEvent Event)
{
if(Event.type == XEventName.KeyPress || Event.type == XEventName.KeyRelease)
KeyReceived(TranslateKey(Event), Event.type == XEventName.KeyPress);
}
public static extern void XNextEvent(IntPtr Display, ref XEvent Event);
public static extern IntPtr XNextEvent(IntPtr display, out XEvent xevent);
private static void EventListenerLoop(object h)
{
var handler = h as IInputHandler;
if(handler == null)
{
return;
}
int initMouseX = -1;
int initMouseY = -1;
using(var ev = new XEvent())
{
handler.Stop = false;
while(!handler.Stop)
{
XNextEvent(DisplayHandle, ev.Pointer);
var type = ev.Type;
switch(type)
{
/*
* Mouse cursor moved
*/
case XEvent.MotionNotify:
var rx = ev.MotionNotifyXRoot;
var ry = ev.MotionNotifyYRoot;
if(initMouseX == -1 && initMouseY == -1)
{
initMouseX = rx;
initMouseY = ry;
continue;
}
var dx = rx - initMouseX;
var dy = ry - initMouseY;
if(!(dx == 0 && dy == 0))
{
handler.MouseMoved(rx, ry, dx, dy);
if(handler.CursorFixed)
{
MoveCursorAbsolute(XRootWindow(DisplayHandle, XDefaultScreen(DisplayHandle)), initMouseX, initMouseY);
}
}
break;
/*
* Mouse button pressed
*/
case XEvent.ButtonPress:
handler.ButtonPressed(ev.Button);
break;
/*
* Mouse button released
*/
case XEvent.ButtonRelease:
handler.ButtonReleased(ev.Button);
break;
/*
* Keyboard key pressed
*/
case XEvent.KeyPress:
handler.KeyPressed(ev.KeyCode);
break;
/*
* Keyboard key released
*/
case XEvent.KeyRelease:
handler.KeyReleased(ev.KeyCode);
break;
}
}
}
EventListenerThread = new Thread(EventListenerLoop);
}
public void Enqueue (XEvent xevent)
{
lock (lockobj) {
EnqueueUnlocked (xevent);
}
}
private void Grow ()
{
int newcap = (xevents.Length * 2);
XEvent [] na = new XEvent [newcap];
if (head + size > xevents.Length) {
Array.Copy (xevents, head, na, 0, xevents.Length - head);
Array.Copy (xevents, 0, na, xevents.Length - head, head + size - xevents.Length);
}
else {
Array.Copy (xevents, head, na, 0, size);
}
xevents = na;
head = 0;
tail = head + size;
}
public void Enqueue (XEvent xevent)
{
if (size == xevents.Length)
Grow ();
xevents [tail] = xevent;
tail = (tail + 1) & (xevents.Length - 1);
size++;
}
protected override XEvent Peek ()
{
X11Hwnd hwnd = (X11Hwnd)hwnds[0];
XEvent xevent = new XEvent ();
xevent.AnyEvent.type = XEventName.Expose;
if (hwnd.PendingExpose) {
xevent.ExposeEvent.window = hwnd.ClientWindow;
} else {
xevent.ExposeEvent.window = hwnd.WholeWindow;
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;
}
public static extern int XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask,
ref XEvent send_event);
public static extern int XLookupString(ref XEvent Key, StringBuilder Buffer, int Count, IntPtr KeySym, IntPtr Useless);
public static extern void XPeekEvent(IntPtr display, out XEvent xevent);
public void AssignStandardTransition(XEvent evt, StandardModel transition)
{
AssignTransition(evt, transition.ToString());
}
public static extern void XWindowEvent(IntPtr display, IntPtr w, int event_mask, ref XEvent event_return);
/* * intended to take RRScreenChangeNotify, or * ConfigureNotify (on the root window) * returns 1 if it is an event type it understands, 0 if not */ int XRRUpdateConfiguration(XEvent *event);
public static void Send(this IEventSender sender, XEvent ev)
{
EventManager.I.SendEvent(sender, ev);
}
static bool CheckEvent(IntPtr display, ref XEvent xevent, IntPtr userData)
{
return(xevent.AnyEvent.window == userData);
}
System.Windows.Forms.Keys TranslateKey(XEvent Event)
{
if(Mapping.ContainsKey(Event.KeyEvent.keycode))
return Mapping[Event.KeyEvent.keycode];
else return StringToWFKey(Event);
}
public bool Dequeue (out XEvent xevent)
{
StartOver:
bool got_xevent = false;
lock (lockobj) {
if (xqueue.Count > 0) {
got_xevent = true;
xevent = xqueue.Dequeue ();
}
else
xevent = new XEvent (); /* not strictly needed, but mcs complains */
}
if (got_xevent) {
if (xevent.AnyEvent.type == XEventName.Expose) {
#if spew
Console.Write ("E");
Console.Out.Flush ();
#endif
X11Hwnd hwnd = (X11Hwnd)Hwnd.GetObjectFromWindow (xevent.AnyEvent.window);
hwnd.AddExpose (xevent.AnyEvent.window == hwnd.ClientWindow,
xevent.ExposeEvent.x, xevent.ExposeEvent.y,
xevent.ExposeEvent.width, xevent.ExposeEvent.height);
goto StartOver;
}
else if (xevent.AnyEvent.type == XEventName.ConfigureNotify) {
#if spew
Console.Write ("C");
Console.Out.Flush ();
#endif
X11Hwnd hwnd = (X11Hwnd)Hwnd.GetObjectFromWindow (xevent.AnyEvent.window);
hwnd.AddConfigureNotify (xevent);
goto StartOver;
}
else {
#if spew
Console.Write ("X");
Console.Out.Flush ();
#endif
/* it was an event we can deal with directly, return it */
return true;
}
}
else {
if (paint_queue.Count > 0) {
xevent = paint_queue.Dequeue ();
#if spew
Console.Write ("e");
Console.Out.Flush ();
#endif
return true;
}
else if (configure_queue.Count > 0) {
xevent = configure_queue.Dequeue ();
#if spew
Console.Write ("c");
Console.Out.Flush ();
#endif
return true;
}
}
if (dispatch_idle && need_dispatch_idle) {
OnIdle (EventArgs.Empty);
need_dispatch_idle = false;
}
lock (lockobj) {
if (CountUnlocked > 0)
goto StartOver;
if (Monitor.Wait (lockobj, NextTimeout (), true)) {
// the lock was reaquired before the
// timeout. meaning an event was
// enqueued by X11Display.XEventThread.
goto StartOver;
}
else {
CheckTimers ();
return false;
}
}
}
private void Awake()
{
mRegionTick = XEvent.Register(I18NEventConst.OnUseRegion, OnSetRegion, FrameworkConst.FrameworkEventGroupName);
RefreshTextValue();
}
public extern static IntPtr XNextEvent(IntPtr display, ref XEvent xevent);
private void Initialize()
{
Name = "blis";
xeventsRunner = true;
SelectInput(XEventMask.KeyPressMask
| XEventMask.VisibilityChangeMask
| XEventMask.KeyReleaseMask
| XEventMask.ButtonPressMask
| XEventMask.ButtonReleaseMask
| XEventMask.EnterWindowMask
| XEventMask.LeaveWindowMask
| XEventMask.PointerMotionMask
| XEventMask.Button1MotionMask
| XEventMask.Button2MotionMask
| XEventMask.Button3MotionMask
| XEventMask.Button4MotionMask
| XEventMask.Button5MotionMask
| XEventMask.ButtonMotionMask
| XEventMask.ExposureMask
| XEventMask.StructureNotifyMask
| XEventMask.FocusChangeMask
| XEventMask.PropertyChangeMask
| XEventMask.ColormapChangeMask
//| XEventMask.PointerMotionHintMask
//| XEventMask.KeymapStateMask
//| XEventMask.SubstructureNotifyMask
//| XEventMask.SubstructureRedirectMask
//| XEventMask.ResizeRedirectMask
);
Screen = new XScreen(Display);
Pointer = new XPointer(Display);
GC = new XGC(Display);
xevents = new XEvent(Display);
xevents.ShapeHandlerEvent += (xevent, window) =>
{
if (ShapeHandlerEvent != null)
{
ShapeHandlerEvent(xevent, window);
}
};
xevents.KeyPressHandlerEvent += (xevent, window, root, subwindow) =>
{
if (KeyPressHandlerEvent != null)
{
KeyPressHandlerEvent(xevent, window, root, subwindow);
}
};
xevents.KeyReleaseHandlerEvent += (xevent, window, root, subwindow) =>
{
if (KeyReleaseHandlerEvent != null)
{
KeyReleaseHandlerEvent(xevent, window, root, subwindow);
}
};
xevents.ButtonPressHandlerEvent += (xevent, window, root, subwindow) =>
{
if (ButtonPressHandlerEvent != null)
{
ButtonPressHandlerEvent(xevent, window, root, subwindow);
}
};
xevents.ButtonReleaseHandlerEvent += (xevent, window, root, subwindow) =>
{
if (ButtonReleaseHandlerEvent != null)
{
ButtonReleaseHandlerEvent(xevent, window, root, subwindow);
}
};
xevents.ExposeHandlerEvent += (xevent, window) =>
{
if (ExposeHandlerEvent != null)
{
ExposeHandlerEvent(xevent, window);
}
};
xevents.EnterNotifyHandlerEvent += (xevent, window, root, subwindow) =>
{
if (EnterNotifyHandlerEvent != null)
{
EnterNotifyHandlerEvent(xevent, window, root, subwindow);
}
};
xevents.LeaveNotifyHandlerEvent += (xevent, window, root, subwindow) =>
{
if (LeaveNotifyHandlerEvent != null)
{
LeaveNotifyHandlerEvent(xevent, window, root, subwindow);
}
};
xevents.MotionNotifyHandlerEvent += (xevent, window, root, subwindow) =>
{
if (MotionNotifyHandlerEvent != null)
{
MotionNotifyHandlerEvent(xevent, window, root, subwindow);
}
};
xevents.FocusInHandlerEvent += (xevent, window) =>
{
if (FocusInHandlerEvent != null)
{
FocusInHandlerEvent(xevent, window);
}
};
xevents.FocusOutHandlerEvent += (xevent, window) =>
{
if (FocusOutHandlerEvent != null)
{
FocusOutHandlerEvent(xevent, window);
}
};
xevents.KeymapNotifyHandlerEvent += (xevent, window) =>
{
if (KeymapNotifyHandlerEvent != null)
{
KeymapNotifyHandlerEvent(xevent, window);
}
};
xevents.GraphicsExposeHandlerEvent += (xevent, window) =>
{
if (GraphicsExposeHandlerEvent != null)
{
GraphicsExposeHandlerEvent(xevent, window);
}
};
xevents.NoExposeHandlerEvent += (xevent, window) =>
{
if (NoExposeHandlerEvent != null)
{
NoExposeHandlerEvent(xevent, window);
}
};
xevents.VisibilityNotifyHandlerEvent += (xevent, window) =>
{
if (VisibilityNotifyHandlerEvent != null)
{
VisibilityNotifyHandlerEvent(xevent, window);
}
};
xevents.CreateNotifyHandlerEvent += (xevent, window, root) =>
{
if (CreateNotifyHandlerEvent != null)
{
CreateNotifyHandlerEvent(xevent, window, root);
}
};
xevents.DestroyNotifyHandlerEvent += (xevent, window) =>
{
if (DestroyNotifyHandlerEvent != null)
{
DestroyNotifyHandlerEvent(xevent, window);
}
};
xevents.UnmapNotifyHandlerEvent += (xevent, window) =>
{
if (UnmapNotifyHandlerEvent != null)
{
UnmapNotifyHandlerEvent(xevent, window);
}
};
xevents.MapNotifyHandlerEvent += (xevent, window) =>
{
if (MapNotifyHandlerEvent != null)
{
MapNotifyHandlerEvent(xevent, window);
}
};
xevents.MapRequestHandlerEvent += (xevent, window, root) =>
{
if (MapRequestHandlerEvent != null)
{
MapRequestHandlerEvent(xevent, window, root);
}
};
xevents.ReparentNotifyHandlerEvent += (xevent, window, root) =>
{
if (ReparentNotifyHandlerEvent != null)
{
ReparentNotifyHandlerEvent(xevent, window, root);
}
};
xevents.ConfigureNotifyHandlerEvent += (xevent, window) =>
{
if (ConfigureNotifyHandlerEvent != null)
{
ConfigureNotifyHandlerEvent(xevent, window);
}
};
xevents.ConfigureRequestHandlerEvent += (xevent, window) =>
{
if (ConfigureRequestHandlerEvent != null)
{
ConfigureRequestHandlerEvent(xevent, window);
}
};
xevents.GravityNotifyHandlerEvent += (xevent, window) =>
{
if (GravityNotifyHandlerEvent != null)
{
GravityNotifyHandlerEvent(xevent, window);
}
};
xevents.ResizeRequestHandlerEvent += (xevent, window) =>
{
if (ResizeRequestHandlerEvent != null)
{
ResizeRequestHandlerEvent(xevent, window);
}
};
xevents.CirculateNotifyHandlerEvent += (xevent, window) =>
{
if (CirculateNotifyHandlerEvent != null)
{
CirculateNotifyHandlerEvent(xevent, window);
}
};
xevents.CirculateRequestHandlerEvent += (xevent, window, root) =>
{
if (CirculateRequestHandlerEvent != null)
{
CirculateRequestHandlerEvent(xevent, window, root);
}
};
xevents.PropertyNotifyHandlerEvent += (xevent, window) =>
{
if (PropertyNotifyHandlerEvent != null)
{
PropertyNotifyHandlerEvent(xevent, window);
}
};
xevents.SelectionClearHandlerEvent += (xevent, window) =>
{
if (SelectionClearHandlerEvent != null)
{
SelectionClearHandlerEvent(xevent, window);
}
};
xevents.SelectionRequestHandlerEvent += (xevent, window, root, subwindow) =>
{
if (SelectionRequestHandlerEvent != null)
{
SelectionRequestHandlerEvent(xevent, window, root, subwindow);
}
};
xevents.SelectionNotifyHandlerEvent += (xevent, window, root) =>
{
if (SelectionNotifyHandlerEvent != null)
{
SelectionNotifyHandlerEvent(xevent, window, root);
}
};
xevents.ColormapNotifyHandlerEvent += (xevent, window) =>
{
if (ColormapNotifyHandlerEvent != null)
{
ColormapNotifyHandlerEvent(xevent, window);
}
};
xevents.ClientMessageHandlerEvent += (xevent, window) =>
{
if (ClientMessageHandlerEvent != null)
{
ClientMessageHandlerEvent(xevent, window);
}
};
xevents.MappingNotifyHandlerEvent += (xevent, window) =>
{
if (MappingNotifyHandlerEvent != null)
{
MappingNotifyHandlerEvent(xevent, window);
}
};
Map();
WindowsThread = new Thread(() => { while (xeventsRunner)
{
xevents.Refresh();
}
});
WindowsThread.Start();
OnInitialized();
}
public extern static int XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask, ref XEvent send_event);
public void Unregister()
{
XEvent.Remove(handler, name, group);
}
public extern static bool XFilterEvent(ref XEvent xevent, IntPtr window);
public Mini(string[] args)
{
if (args.Length > 0)
{
if (args[0].Equals("--version"))
{
Console.WriteLine(VERSION_STRING);
Environment.Exit(0);
}
}
XGCValues gv;
XSetWindowAttributes sattr;
focused_client = null;
focus_model = DEFAULT_FOCUS_MODEL;
// for (int i = 0; i < argc; i++)
// command_line = command_line + argv[i] + " ";
try {
dpy = new XDisplay(":0");
try {
font = new XFont(dpy, DEFAULT_FONT);
} catch {
font = new XFont(dpy, "Fixed");
}
} catch (Exception e) {
Console.WriteLine("{0} check your DISPLAY variable.", e.Message);
Environment.Exit(-1);
}
XEvent ev = new XEvent(dpy);
ev.ErrorHandlerEvent += new ErrorHandler(ErrorHandler);
// SET UP ATOMS
atom_wm_state = new XAtom(dpy, "WM_STATE", false);
atom_wm_change_state = new XAtom(dpy, "WM_CHANGE_STATE", false);
atom_wm_protos = new XAtom(dpy, "WM_PROTOCOLS", false);
atom_wm_delete = new XAtom(dpy, "WM_DELETE_WINDOW", false);
atom_wm_takefocus = new XAtom(dpy, "WM_TAKE_FOCUS", false);
XSetWindowAttributes pattr = new XSetWindowAttributes();
pattr.override_redirect = true;
_button_proxy_win = new XWindow(dpy, new Rectangle(-80, -80, 24, 24));
_button_proxy_win.ChangeAttributes(XWindowAttributeFlags.CWOverrideRedirect, pattr);
// SETUP COLORS USED FOR WINDOW TITLE BARS and WINDOW BORDERS
fg = new XColor(dpy, DEFAULT_FOREGROUND_COLOR);
bg = new XColor(dpy, DEFAULT_BACKGROUND_COLOR);
bd = new XColor(dpy, DEFAULT_BORDER_COLOR);
fc = new XColor(dpy, DEFAULT_FOCUS_COLOR);
focused_border = new XColor(dpy, FOCUSED_BORDER_COLOR);
unfocused_border = new XColor(dpy, UNFOCUSED_BORDER_COLOR);
//shape = XShapeQueryExtension(dpy, &shape_event, &dummy);
move_curs = new XCursor(dpy, XCursors.XC_fleur);
arrow_curs = new XCursor(dpy, XCursors.XC_left_ptr);
root.DefineCursor(arrow_curs);
gv.function = XGCFunctionMask.GXcopy;
gv.foreground = fg.Pixel;
gv.font = font.FID;
string_gc = new XGC(dpy, root, XGCValuesMask.GCFunction | XGCValuesMask.GCForeground | XGCValuesMask.GCFont, gv);
gv.foreground = unfocused_border.Pixel;
unfocused_gc = new XGC(dpy, root, XGCValuesMask.GCForeground | XGCValuesMask.GCFont, gv);
gv.foreground = fg.Pixel;
focused_title_gc = new XGC(dpy, root, XGCValuesMask.GCForeground | XGCValuesMask.GCFont, gv);
gv.foreground = bd.Pixel;
gv.line_width = DEFAULT_BORDER_WIDTH;
border_gc = new XGC(dpy, root, XGCValuesMask.GCFunction | XGCValuesMask.GCForeground | XGCValuesMask.GCLineWidth, gv);
gv.foreground = fg.Pixel;
gv.function = XGCFunctionMask.GXinvert;
gv.subwindow_mode = XSubwindowMode.IncludeInferiors;
invert_gc = new XGC(dpy, root, XGCValuesMask.GCForeground | XGCValuesMask.GCFunction | XGCValuesMask.GCSubwindowMode | XGCValuesMask.GCLineWidth | XGCValuesMask.GCFont, gv);
sattr.event_mask = XEventMask.SubstructureRedirectMask | XEventMask.SubstructureNotifyMask | XEventMask.ButtonPressMask | XEventMask.ButtonReleaseMask | XEventMask.FocusChangeMask | XEventMask.EnterWindowMask | XEventMask.LeaveWindowMask | XEventMask.PropertyChangeMask | XEventMask.ButtonMotionMask;
root.ChangeAttributes(XWindowAttributeFlags.CWEventMask, sattr);
queryWindowTree();
ev.KeyPressHandlerEvent += new KeyPressHandler(handleKeyPressEvent);
ev.ButtonPressHandlerEvent += new ButtonPressHandler(handleButtonPressEvent);
ev.ButtonReleaseHandlerEvent += new ButtonReleaseHandler(handleButtonReleaseEvent);
ev.ConfigureRequestHandlerEvent += new ConfigureRequestHandler(handleConfigureRequestEvent);
ev.MotionNotifyHandlerEvent += new MotionNotifyHandler(handleMotionNotifyEvent);
ev.MapRequestHandlerEvent += new MapRequestHandler(handleMapRequestEvent);
ev.UnmapNotifyHandlerEvent += new UnmapNotifyHandler(handleUnmapNotifyEvent);
ev.DestroyNotifyHandlerEvent += new DestroyNotifyHandler(handleDestroyNotifyEvent);
ev.EnterNotifyHandlerEvent += new EnterNotifyHandler(handleEnterNotifyEvent);
ev.FocusInHandlerEvent += new FocusInHandler(handleFocusInEvent);
ev.FocusOutHandlerEvent += new FocusOutHandler(handleFocusOutEvent);
ev.PropertyNotifyHandlerEvent += new PropertyNotifyHandler(handlePropertyNotifyEvent);
ev.ExposeHandlerEvent += new ExposeHandler(handleExposeEvent);
ev.ShapeHandlerEvent += new ShapeHandler(handleShapeEvent);
}
public extern static void XPeekEvent(IntPtr display, ref XEvent xevent);
/// <summary> Define the "delete window action", invoked by the windows manager on window's decoration close [X] button. </summary>
/// <param name="widget"> The widget, that is source of the event. Typically the the shell's toplevel widget. <see cref="System.IntPtr"/> </param>
/// <param name="xevent"> The event, that is invoked. <see cref="XEvent"/> </param>
/// <param name="parameters"> Additional parameters (as String[]). Not used for WM_DELETE_WINDOW. <see cref="System.IntPtr"/> </param>
/// <param name="num_params"> The number of additional parameters. 0 for WM_DELETE_WINDOW. <see cref="XCardinal"/> </param>
/// <remarks> The prototype must match the XtActionProc delegate. </remarks>
public void DeleteWindowAction(IntPtr widget, ref XEvent xevent, IntPtr parameters, ref XCardinal num_params)
{
Console.WriteLine(CLASS_NAME + "::DeleteWindowAction() For Atthena dialog.");
this.Close();
}
extern internal static bool SendEvent(Display display, Window window, bool propagate,
[MarshalAs(UnmanagedType.SysInt)] EventMask event_mask, ref XEvent event_send);
public PaintQueue(int size)
{
hwnds = new ArrayList(size);
xevent = new XEvent();
xevent.AnyEvent.type = XEventName.Expose;
}
internal static extern bool IfEvent(Display display, ref XEvent event_return,
/*[MarshalAs(UnmanagedType.FunctionPtr)] */ CheckEventPredicate predicate, /*XPointer*/ IntPtr arg);
internal static extern bool CheckMaskEvent(Display display, EventMask event_mask, ref XEvent event_return);
public static extern void XNextEvent(IntPtr display, ref XEvent even);
public static extern bool XFilterEvent(ref XEvent xevent, IntPtr window);
public static extern bool XCheckMaskEvent(IntPtr display, int even_mask, ref XEvent even);
public static extern unsafe int Xutf8LookupString(IntPtr xic, ref XEvent xevent, void *buffer, int num_bytes, out IntPtr keysym, out UIntPtr status);
private async Task useRegion(XRegion region)
{
if (region == null)
{
throw new ArgumentNullException(nameof(region));
}
mDicts.Clear();
if (region.JsonDicts != null && region.JsonDicts.Count > 0)
{
List <Task <I18NTable> > load_task = new List <Task <I18NTable> >();
List <int> load_task_index = new List <int>();
for (var i = 0; i < region.JsonDicts.Count; i++)
{
if (!region.JsonDicts[i].LoadPath.IsNullOrEmpty())
{
load_task.Add(this.getJsonDict(region.JsonDicts[i].LoadPath));
load_task_index.Add(i);
}
}
if (load_task.Count > 0)
{
await Task.WhenAll(load_task);
for (var i = 0; i < load_task.Count; i++)
{
foreach (var item in load_task)
{
var json_obj = item.Result;
bool base64_value = region.JsonDicts[load_task_index[i]].Base64Value;
string groupName = region.JsonDicts[load_task_index[i]].GroupName;
if (groupName.IsNullOrEmpty())
{
groupName = I18NConst.DefaultGroupName;
}
foreach (var kv in json_obj.data)
{
if (!mDicts.ContainsKey(groupName))
{
mDicts.Add(groupName, new Dictionary <string, string>());
}
if (!mDicts[groupName].ContainsKey(kv.k))
{
if (base64_value)
{
try
{
string _value = kv.v.DecodeBase64();
mDicts[groupName].Add(kv.k, _value);
}
catch
{
Debug.LogError($"[TinaX.I18N] Decode base64 error: Json: {region.JsonDicts[load_task_index[i]].LoadPath} | Key: {kv.k}");
}
}
else
{
mDicts[groupName].Add(kv.k, kv.v);
}
}
}
}
}
}
}
if (region.AssetDicts != null && region.AssetDicts.Count > 0)
{
foreach (var item in region.AssetDicts)
{
if (item.Asset == null)
{
continue;
}
string groupName = item.GroupName.IsNullOrEmpty() ? I18NConst.DefaultGroupName : item.GroupName;
foreach (var kv in item.Asset.data)
{
if (!mDicts.ContainsKey(groupName))
{
mDicts.Add(groupName, new Dictionary <string, string>());
}
if (!mDicts[groupName].ContainsKey(kv.k))
{
mDicts[groupName].Add(kv.k, kv.v);
}
}
}
}
mRegionName = region.Name;
XEvent.Call(I18NEventConst.OnUseRegion, region.Name, TinaX.Const.FrameworkConst.FrameworkEventGroupName);
}
/// <summary>
/// 注册事件
/// </summary>
/// <param name="eventName">事件名</param>
/// <param name="callback">事件回调</param>
protected void EventRegister(string eventName, System.Action <System.Object> callback)
{
mEventPool.Add(XEvent.Register(eventName, callback));
}
public static extern void XPeekEvent(IntPtr display, ref XEvent event_return);
