event.c

rxvt经典的linux下的终端.小巧实用

		    else
		    {
			event->type=LeaveNotify;
			event->xcrossing.x=LOWORD(lParam);
			event->xcrossing.y=HIWORD(lParam);
			event->xcrossing.window = (Window)NT_find_window_from_id(NT_CWIN);
		    }
		}
		else
		{
		    event->type=MotionNotify;    /* Fill out mouse event */
		    event->xmotion.window=(Window)window;
		    event->xmotion.x=pt.x=LOWORD(lParam);
		    event->xmotion.y=pt.y=HIWORD(lParam);
		    event->xmotion.time=GetTickCount();
		    ClientToScreen(hWnd,&pt);     /* Translate coordinates */
		    event->xmotion.x_root=pt.x;
		    event->xmotion.y_root=pt.y;
		    if (wParam&MK_CONTROL)
			st|=ControlMask;
		    if (wParam&MK_SHIFT)
			st|=ShiftMask;
		    if (wParam&MK_LBUTTON)
			st|=Button1Mask;
		    if (wParam&MK_MBUTTON)
			st|=Button2Mask;
		    if (wParam&MK_RBUTTON)
			st|=Button3Mask;
		    event->xmotion.state=st;
		}
		NT_CWIN=(NT_window *)hWnd;
		break;
	    case WM_MOUSEWHEEL:
		event->type=ButtonRelease;
		event->xbutton.x=LOWORD(lParam);
		event->xbutton.y=HIWORD (lParam);
		event->xbutton.button=HIWORD(wParam)>32768?Button5:Button4;
		event->xbutton.window=(Window)window;
		event->xbutton.time=GetTickCount();
		if (wParam&MK_CONTROL)
		    st|=ControlMask;
		if (wParam&MK_SHIFT)
		    st|=ShiftMask;
		if (wParam&MK_LBUTTON)
		    st|=Button1Mask;
		if (wParam&MK_MBUTTON)
		    st|=Button2Mask;
		if (wParam&MK_RBUTTON)
		    st|=Button3Mask;
		event->xbutton.state=st;
		break;
	    case WM_SYSCHAR:
	    case WM_CHAR:
		event->type=KeyPress;
		event->xkey.state=NT_get_state();
		event->xkey.x=event->xkey.y=0; /* Inside the window */
		event->xkey.keycode=LOWORD(wParam);
 		switch (event->xkey.keycode)
		  {
		  case VK_ADD:     event->xkey.keycode=XK_KP_Add;  break;
		  case VK_SUBTRACT:event->xkey.keycode=XK_KP_Subtract; break;
		  }
		if (GetKeyState(VK_CONTROL) & 0x8000) {
		    if (event->xkey.keycode == 32) { event->xkey.keycode=0; }
		    if (event->xkey.keycode >255 ) { event->xkey.keycode=0; }
		}
		event->xkey.window=(Window)window;
		break;
	    case WM_KEYDOWN:
		event->type=KeyPress;
		switch (wParam)
		{
		    case VK_CANCEL:  key=XK_Cancel;      break;
		    case VK_CLEAR:   key=XK_Clear;       break;
		/*  causes AltGr to create a keypress */
		/*  case VK_MENU:    key=XK_Alt_L;       break;*/
		    case VK_PAUSE:   key=XK_Pause;       break;
		    case VK_PRIOR:   key=XK_Prior;       break;
		    case VK_NEXT:    key=XK_Next;        break;
		    case VK_END:     key=XK_End;         break;
		    case VK_HOME:    key=XK_Home;        break;
		    case VK_LEFT:    key=XK_Left;        break;
		    case VK_UP:      key=XK_Up;          break;
		    case VK_RIGHT:   key=XK_Right;       break;
		    case VK_DOWN:    key=XK_Down;        break;
		    case VK_SELECT:  key=XK_Select;      break;
		    case VK_PRINT:   key=XK_Print;       break;
		    case VK_EXECUTE: key=XK_Execute;     break;
		    case VK_INSERT:  key=XK_Insert;      break;
		    case VK_DELETE:  key=XK_Delete;      break;
		    case VK_HELP:    key=XK_Help;        break;
		    case VK_NUMLOCK: key=XK_Num_Lock;    break;
		    case VK_SCROLL:  key=XK_Scroll_Lock; break;
		    case VK_BACK:    key=XK_BackSpace; break;
                    case VK_F1:      key=XK_F1;          break;
                    case VK_F2:      key=XK_F2;          break;
                    case VK_F3:      key=XK_F3;          break;
                    case VK_F4:      key=XK_F4;          break;
                    case VK_F5:      key=XK_F5;          break;
                    case VK_F6:      key=XK_F6;          break;
                    case VK_F7:      key=XK_F7;          break;
                    case VK_F8:      key=XK_F8;          break;
                    case VK_F9:      key=XK_F9;          break;
                    case VK_F10:     key=XK_F10;         break;
                    case VK_F11:     key=XK_F11;         break;
                    case VK_F12:     key=XK_F12;         break;
		    case VK_ADD:     key=XK_KP_Add;      break;
		    case VK_SUBTRACT:key=XK_KP_Subtract; break;
		    default:         key=0;              break;
		}
		if (key == 0) {
		    event->type = -1;
		}
		else
		{
		    event->xkey.keycode=key;
		    event->xkey.window=(Window)window;
		    event->xkey.state=NT_get_state();
		    event->xkey.x=event->xkey.y=0; /* Inside the window */
		}
		break;
	    case WM_DESTROY:
	    case WM_QUIT:
	    case WM_CLOSE:
		event->type = ClientMessage;
		event->xclient.format = 32;
		event->xclient.data.l[0] = XInternAtom(NULL,"WM_DELETE_WINDOW", FALSE);
		break;
	    case USR_EnterNotify:
		event->type = EnterNotify;
		event->xcrossing.x = LOWORD(lParam);
		event->xcrossing.y = HIWORD(lParam);
		event->xcrossing.window = (Window)window;
		break;
	    case WM_MOVE:
		if (window->min==0)
		{
		    window->x =  LOWORD(lParam);
		    window->y =  HIWORD(lParam);
		    NT_configureNotify(window,window->x,window->y);
		    event->type = ConfigureNotify;
		    event->xconfigure.window = (Window)window;
		    event->xconfigure.x = 0;  /* client area is always @ 0 */
		    event->xconfigure.y = 0;
		    event->xconfigure.width = window->wdth;
		    event->xconfigure.height = window->hght;
		    event->xconfigure.above = Above;
		}
		break;
	    case WM_SIZING:
		event->type = ConfigureNotify;
		window->wdth =	LOWORD(lParam);
		if (window->wdth<window->minx)
		    window->wdth = window->minx;
		window->hght =	HIWORD(lParam);
		if (window->hght<window->minx)
		    window->hght = window->miny;
		NT_configureNotify(window,window->x,window->y);
		event->xconfigure.window = (Window)window;
		event->xconfigure.x = 0;
		event->xconfigure.y = 0;
		event->xconfigure.width = window->wdth;
		event->xconfigure.height = window->hght;
		event->xconfigure.above = Above;
		break;
	    case WM_SIZE:
		switch(wParam)
		{
		    case SIZE_MINIMIZED:
			event->type=UnmapNotify;
			window->min=1;
			break;
		    default:
			event->type = ConfigureNotify;
			window->wdth =  LOWORD(lParam);
			if (window->wdth<window->minx)
			    window->wdth = window->minx;
			window->hght =  HIWORD(lParam);
			if (window->hght<window->minx)
			    window->hght = window->miny;
			event->xconfigure.window = (Window)window;
			event->xconfigure.x = 0;
			event->xconfigure.y = 0;
			event->xconfigure.width = window->wdth;
			event->xconfigure.height = window->hght;
			event->xconfigure.above = Above;
#if !defined(WIN9X)						
			if (window->min) event->type=MapNotify;
#endif						
			window->min=0;
			break;
		}
		break;
	    case WM_DESTROYCLIPBOARD:
		event->type = SelectionClear;
		event->xselectionclear.time = GetTickCount();
		break;
	    case USR_MapNotify:
		event->type=MapNotify;
		break;
	    case USR_ConvertSelection:
		event->type=SelectionNotify;
		event->xselection.requestor = (Window)window;
		event->xselection.property = XA_CUT_BUFFER0;			
		break;
	    default:
		break;
	}
    } while(0);
    return (event==NULL?0: (event->type==-1?0:1));
}
/*****************************************************************\


	Function: XCheckWindowEvent
	Inputs:   display, window, event mask.
	Returned: pointer to filled in event structure, status.

	Comments: This is fudged at the moment to work with the toolkit.
		  The event system needs rewriting to account properly for
		  event masks.

\*****************************************************************/

BoolDef
XCheckTypedEvent(display,ev,rep)
Display *display;
int ev;
XEvent *rep;
{
	xtrace("XCheckTypedEvent\n");
	return (False);
}

BoolDef
XCheckWindowEvent(display,w,emask,ev)
Display *display;
Window w;
long emask;
XEvent *ev;
{
	NT_window *ntw=(NT_window *)w;
	MSG msg;
	BoolDef status = 0;

	xtrace("XCheckWindowEvent\n");
	if (emask&0)
		if (PeekMessage(&msg,ntw->w,USR_MapNotify,
						USR_MapNotify,PM_REMOVE)||
		    PeekMessage(&msg,ntw->w,WM_PAINT,WM_PAINT,PM_REMOVE))
		{
			cjh_printf("removed message\n");
			ev->type=ConfigureNotify;
			status = 1;
		}
	return(status);
}

/*
  XPending checks for x events pending.
  We don't know if we have x events until we process
  the win events.
  */
int
XPending (display)
Display *display;
{
	MSG msg;
	/*	xtrace("XPending\n"); */
	while(wineventq->count<=0 && PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
	{
		doTranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	return wineventq->count;
}

int
XPutBackEvent(display,event)
Display *display;
XEvent *event;
{
	xtrace("XPutBackEvent\n");
	return 0;
}


StatusDef
XSendEvent(display,w,prop,emask,event)
Display *display;
Window w;
BoolDef prop;
long emask;
XEvent *event;
{
	xtrace("XSendEvent\n");
	return 0;
}

/* I'm tempted to flush the windows queue
**   before checking, but I think that would
**   break the assumtion that most of the WM_PAINT
**   messges are only going to be dispatched when
**   the app is directly calling us.
*/

BoolDef
XCheckTypedWindowEvent(
	Display* display,
	Window w,
	int event_type,
	XEvent* event_return)
{
	int i,j;
	xtrace("XCheckTypedWindowEvent\n");
	if (w==0) return 0;
	/*
	i = wineventq->next;
	while(i != wineventq->avail)
	{
		if (wineventq->list[i].window==(NT_window*)w)
		{
			WinEventToXEvent(&wineventq->list[i],event_return);
			if (event_return->type == event_type)
			{
				break;
			}
		}
		i++;
		if (i>wineventq->num) i=0;
	}
	if (i != wineventq->avail)
	{
		while(i != wineventq->next)
		{
			j =i-1;
			if (j<0) j= wineventq->num;
			copyWinEvent(&wineventq->list[i],&wineventq->list[j]);
			i = j;
		}
		wineventq->next++;
		wineventq->count--;
		cjh_printf("removed an event\n");
		return 1;
	}
	*/
	return 0;
}

/*****************************************************************\


	Function: XWindowEvent
	Inputs:   display, window, event mask.
	Returned: pointer to filled in event structure.

	Comments: This is fudged at the moment to work with the toolkit.
		  The event system needs rewriting to account properly for
		  event masks.

\*****************************************************************/

int
XWindowEvent(display,w,emask,rep)
Display *display;
Window w;
long emask;
XEvent *rep;
{
	NT_window *ntw=(NT_window *)w;
	MSG msg;

	xtrace("XWindowEvent\n");
	if (emask&ExposureMask)
	{
		GetMessage(&msg,ntw->w,USR_MapNotify,USR_MapNotify);
		rep->type=ConfigureNotify;
	}
	return 0;
}



/*****************************************************************\

	Function: XNextEvent
	Inputs:   display, event structure pointer.

	Comments: Windows routines receive messages (events) in two ways:
		  firstly by GetMessage, which takes messages from the
		  calling thread's message queue, and secondly by the
		  window function being called with events as arguments.
		  To simulate the X system, we get messages from the queue
		  and pass them to the window function anyway, which
		  processes them and fills out the local XEvent structure.
		  DispatchMessage calls the window procedure and waits until
		  it returns. Translate message turns WM_KEYUP/DOWN messages
		  into WM_CHAR.

\*****************************************************************/

int
XNextEvent(Display *display,XEvent  *event)
{
    MSG msg;
	
    xtrace("XNextEvent\n");

    /* if there isn't already an event in the pipe, this will block */
    while(wineventq->count <= 0 && GetMessage(&msg, NULL, 0, 0)>0)
    {		
	doTranslateMessage(&msg);
	DispatchMessage(&msg);
    }
    if (wineventq->count>0)
    {
	getQdEvent(wineventq,event);
    }
    else
    {
	/* hmm, GetMessage failed, maybe we're supposed to quit */
	event->type=ClientMessage;
	event->xclient.format = 32;
	event->xclient.data.l[0] = XInternAtom(NULL,"WM_DELETE_WINDOW", FALSE);
	return 1;
    }
    return 1;
}

BoolDef
XFilterEvent(XEvent* event,Window window)
{
	xtrace("XFilterEvent\n");
	return 0;
}

BoolDef
XQueryPointer(
	Display* display,
	Window w,
	Window* root_return,
	Window* child_return,
	int* root_x_return,
	int* root_y_return,
	int* win_x_return,
	int* win_y_return,
	unsigned int* mask_return)
{
    POINT point;
	RECT rect;
	xtrace("XQueryPointer\n");
    GetCursorPos(&point);
    *root_x_return = point.x;
    *root_y_return = point.y;
	GetWindowRect(((NT_window*)w)->w,&rect);
	*win_x_return= point.x - rect.left;
	*win_y_return= point.y - rect.top;
	*mask_return = NT_get_state();
    return True;
}

int
XConvertSelection(
    Display *display,
    Atom sel, Atom target, Atom prop,
    Window req,	
    Time time)
{
    xtrace("XConvertSelection\n");
    QEvent(wineventq,(NT_window*)req,USR_ConvertSelection,0,0L);
    NT_wakeup(((NT_window*)req)->w);
    return 0;
}