Ejemplo n.º 1
0
void zoom(const char *arg) {
    if (show.rendered < show.count - 1) { /* ensure rendering is done */
        warn();
        return;
    }
    XDefineCursor(dpy,win,XCreateFontCursor(dpy,130));
    XEvent ev;
    int x1,y1,x2=-1,y2;
    while ( !XNextEvent(dpy,&ev) && ev.type!=ButtonPress && ev.type!=KeyPress );
    if (ev.type == KeyPress) {
        XPutBackEvent(dpy,&ev);
        XDefineCursor(dpy,win,invisible_cursor);
        return;
    }
    XGrabPointer(dpy,ev.xbutton.window,True,
                 PointerMotionMask | ButtonReleaseMask, GrabModeAsync,
                 GrabModeAsync,None,None,CurrentTime);
    x1 = ev.xbutton.x;
    y1 = ev.xbutton.y;
    while (!XNextEvent(dpy,&ev) && ev.type != ButtonRelease && ev.type!=KeyPress) {
        XCopyArea(dpy,show.slide[show.num],win,gc,0,0,
                  aspx*sw,aspy*sh,(sw-aspx*sw)/2,(sh-aspy*sh)/2);
        XDrawRectangle(dpy,win,hgc,x1,y1,ev.xbutton.x-x1,ev.xbutton.y-y1);
        XSync(dpy,True);
    }
    if (ev.type == KeyPress) {
        XPutBackEvent(dpy,&ev);
        XDefineCursor(dpy,win,invisible_cursor);
        return;
    }
    x2 = ev.xbutton.x;
    y2 = ev.xbutton.y;
    mute("black");
    white_muted = True;
    Pixmap region = XCreatePixmap(dpy,root,sw,sh,DefaultDepth(dpy,scr));
    XFillRectangle(dpy,region,wgc,0,0,sw,sh);
    PopplerPage *page = poppler_document_get_page(pdf,show.num);
    cairo_surface_t *target = cairo_xlib_surface_create(
                                  dpy, region, DefaultVisual(dpy,scr), sw, sh);
    cairo_t *cairo = cairo_create(target);
    double xscale = show.scale * sw/ (x2-x1);
    double yscale = show.scale * sh/ (y2-y1);
    if (arg) {
        if (xscale > yscale) xscale = yscale;
        else yscale = xscale;
    }
    double xoff = ((sw-aspx*sw)/2 - x1)/show.scale*xscale;
    double yoff = ((sh-aspy*sh)/2 - y1)/show.scale*yscale;
    cairo_translate(cairo,xoff,yoff);
    cairo_scale(cairo,xscale,yscale);
    poppler_page_render(page,cairo);
    cairo_surface_destroy(target);
    cairo_destroy(cairo);
    XCopyArea(dpy,region,win,gc,0,0,sw,sh,0,0);
    XFreePixmap(dpy,region);
    XDefineCursor(dpy,win,invisible_cursor);
    XFlush(dpy);
}
Ejemplo n.º 2
0
static void dot(cairo_t *ctx, cairo_surface_t *buf,
		cairo_surface_t *cbuf, Theme *q) {
	XEvent ev;
	double qe = q->e;
	while (!XNextEvent(dpy, &ev)) {
		if (ev.type == KeyPress) { XPutBackEvent(dpy, &ev); break; }
		else if (ev.type == ButtonPress) {
			if (ev.xbutton.button == 1) q->e += 4;
			else if (ev.xbutton.button == 2) q->e = qe;
			else if (ev.xbutton.button == 3) q->e -= 4;
			if (q->e < 4) q->e = 4;
			else if (q->e > sh/4.0) q->e = sh/4.0;
			ev.type = MotionNotify;
		}
		if (ev.type == MotionNotify) {
			cairo_set_source_surface(ctx, cbuf, 0, 0);
			cairo_paint(ctx);
			cairo_set_source_rgba(ctx, q->R, q->G, q->B, q->A);
			cairo_arc(ctx, ev.xbutton.x, ev.xbutton.y, q->e, 0, 2*M_PI);
			cairo_fill(ctx);
			cairo_set_source_surface(show->target[0].ctx, buf, 0, 0);
			cairo_paint(show->target[0].ctx);
		}
	}
}
Ejemplo n.º 3
0
static void pen(cairo_t *ctx, cairo_surface_t *buf,
		cairo_surface_t *cbuf, Theme *q) {
	XEvent ev;
	Bool on = False;
	XDefineCursor(dpy, wshow, crosshair_cursor);
	while (!XNextEvent(dpy, &ev)) {
		if (ev.type == KeyPress) { XPutBackEvent(dpy, &ev); break; }
		else if (ev.type == ButtonPress) {
			if (ev.xbutton.button == 1 && (on = !on) ) {
				cairo_new_sub_path(ctx);
				cairo_move_to(ctx, ev.xbutton.x, ev.xbutton.y);
			}
			else if (ev.xbutton.button == 2) { break; }
			else if (ev.xbutton.button == 3) {
				// TODO save changes to slide
				break;
			}
		}
		else if (ev.type == MotionNotify && on) {
			cairo_set_source_surface(ctx, cbuf, 0, 0);
			cairo_paint(ctx);
			cairo_set_source_rgba(ctx, q->R, q->G, q->B, q->A);
			cairo_line_to(ctx, ev.xbutton.x, ev.xbutton.y);
			cairo_stroke_preserve(ctx);
			cairo_set_source_surface(show->target[0].ctx, buf, 0, 0);
			cairo_paint(show->target[0].ctx);
		}
	}
}
Ejemplo n.º 4
0
void
Refresh(void)
{

    XEvent report;
    unsigned long mask_event;
    int count = 0;

/*
 * Check for X events that require redrawing the screen...
 */
    while (1) {
	mask_event =
	    ButtonPressMask | StructureNotifyMask | ExposureMask;
	while (XCheckMaskEvent(G_xStruct->display,
			       mask_event,
			       &report) == True) {
	    /* put it back first before checking for ButtonPress */
	    XPutBackEvent(G_xStruct->display, &report);
	    if (cur_img.error_condition == FALSE) {
		if (XCheckTypedWindowEvent(G_xStruct->display,
		       xcur_img.image_window, ButtonPress, &report) == True)
		    return;
	    } else {
		if (XCheckTypedWindowEvent(G_xStruct->display,
				G_big_window, ButtonPress, &report) == True)
		    return;
	    }
	    RefreshImageData(&cur_img, &xcur_img);
	}
	(void) sleep(1);
    }

}
Ejemplo n.º 5
0
Archivo: wind.c Proyecto: amigan/phoned
void htime(XtPointer client_data, XtIntervalId *timer) 
{
 XEvent bogus_event;
 Display** displays;
 int numdr;
#ifdef DEBUG
	printf("here\n");
#endif
	if(--tsec == 0) {
//  XtDestroyApplicationContext (app_context);
#ifdef DEBUG
	printf("alive\n");
#endif
	/* This is EVIL */
  tflag = 1;
 XtGetDisplays(app_context, &displays, &numdr);
 bogus_event.type = 0;        /* XAnyEvent type, ignored. */
bogus_event.xany.display = displays[0];
bogus_event.xany.window = 0;
XPutBackEvent(displays[0], &bogus_event);
  XtAppSetExitFlag (app_context); }
	else {
  timer = (XtIntervalId)XtAppAddTimeOut(app_context, 
		  (unsigned long)1000, 
		  (XtTimerCallbackProc)htime, 
		  test);
	}
}
Ejemplo n.º 6
0
static void custom(cairo_t *ctx, cairo_surface_t *buf,
		cairo_surface_t *cbuf, Theme *q, const char *str) {
	XEvent ev;
	double qe = q->e;
	while (!XNextEvent(dpy, &ev)) {
		if (ev.type == KeyPress) { XPutBackEvent(dpy, &ev); break; }
		else if (ev.type == ButtonPress) {
			if (ev.xbutton.button == 1) q->e += 4;
			else if (ev.xbutton.button == 2) q->e = qe;
			else if (ev.xbutton.button == 3) q->e -= 4;
			if (q->e < 4) q->e = 4;
			else if (q->e > sh/4.0) q->e = sh/4.0;
			ev.type = MotionNotify;
		}
		if (ev.type == MotionNotify) {
			cairo_set_source_surface(ctx, cbuf, 0, 0);
			cairo_paint(ctx);
			cairo_set_source_rgba(ctx, q->R, q->G, q->B, q->A);
			cairo_move_to(ctx, ev.xbutton.x, ev.xbutton.y);
			cairo_set_font_size(ctx, q->e);
			cairo_show_text(ctx, str);
			cairo_fill(ctx);
			cairo_set_source_surface(show->target[0].ctx, buf, 0, 0);
			cairo_paint(show->target[0].ctx);
		}
	}
}
Ejemplo n.º 7
0
Archivo: xlib.c Proyecto: jacereda/glcv
static int isAutoRepeat(Display * dpy, Window win, XEvent * e) {
        XEvent next;
        XCheckTypedWindowEvent(dpy, win, KeyPress, &next);
        XPutBackEvent(dpy, &next);
        return next.xkey.keycode == e->xkey.keycode
                && next.xkey.time - e->xkey.time < 2;
}
Ejemplo n.º 8
0
void rclick_root(void)
{
	XEvent ev;
	if (!grab(root, MouseMask, None))
	{
		return;
	}
	draw_menubar();
	do
	{
		XMaskEvent(dsply, MouseMask|KeyMask, &ev);
		switch (ev.type)
		{
			case MotionNotify:
				if (ev.xmotion.y < BARHEIGHT())
				{
					ungrab();
					rclick_taskbar(ev.xmotion.x);
					return;
				}
				break;
			case KeyPress:
				XPutBackEvent(dsply, &ev);
				break;
		}
	}
	while (ev.type != ButtonRelease && ev.type != KeyPress);

	redraw_taskbar();
	ungrab();
}
Ejemplo n.º 9
0
void _glfwPlatformWaitEvents(void)
{
    XEvent event;

    // Block waiting for an event to arrive
    XNextEvent(_glfwLibrary.X11.display, &event);
    XPutBackEvent(_glfwLibrary.X11.display, &event);

    _glfwPlatformPollEvents();
}
Ejemplo n.º 10
0
void
idle_timer (XtPointer closure, XtIntervalId *id)
{
  saver_info *si = (saver_info *) closure;
  XEvent fake_event;
  fake_event.type = 0;	/* XAnyEvent type, ignored. */
  fake_event.xany.display = si->dpy;
  fake_event.xany.window  = 0;
  XPutBackEvent (si->dpy, &fake_event);
}
Ejemplo n.º 11
0
int OGLwin_QTest(void)
{
    XEvent e;

    if (XCheckIfEvent(Dsp, &e, CheckForWindowEvent, (XPointer) XWindow)) {
	XPutBackEvent(Dsp, &e);
	return (1);
    } else
	return (0);

}
Ejemplo n.º 12
0
int gfx_event_waiting()
{
	XEvent event;

	if(XCheckWindowEvent(gfx_display,gfx_window,KeyPressMask|ButtonPressMask,&event)) {
		XPutBackEvent(gfx_display,&event);
		return 1;
	} else {
		return 0;
	}	
}
Ejemplo n.º 13
0
int kbhit()
{
  XEvent xev;

  if (XCheckWindowEvent(dpy, win, KeyPressMask, &xev))
  {
    XPutBackEvent(dpy, &xev);
    return(1);
  }
  return(0);
}
Ejemplo n.º 14
0
void sendMessage(void * vp, unsigned long type , unsigned long message){
    BWindow self = vp;
    XEvent xe;
    xe.type = ClientMessage;
    xe.xclient.window = self->hwindow;
    xe.xclient.message_type = bl_message;
    xe.xclient.data.l[0] = type;
    xe.xclient.data.l[1] = (long)self;
    xe.xclient.data.l[2] = (long)message;
    XPutBackEvent(display, &xe);
    XSync(display, False);
}
Ejemplo n.º 15
0
//retorna 1 para evento de teclado e 2 para evento de mouse
//0 se não tem nenhum evento no buffer
int evento_aconteceu(){
       XEvent event;

       repintar();

       while (1) {
               if(XCheckMaskEvent(gfx_display,-1,&event)) {
                       if(event.type==KeyPress) {
                               XPutBackEvent(gfx_display,&event);
                               return 1;
                       } else if (event.type==ButtonPress) {
                               XPutBackEvent(gfx_display,&event);
                               return 2;
                       } else {
                               return 0;
                       }
               } else {
                       return 0;
               }
       }
}
Ejemplo n.º 16
0
void rclick_taskbar(int x)
{
	XEvent ev;
	int mousex, mousey;
	Rect bounddims;
	unsigned int current_item = UINT_MAX;
	Window constraint_win;
	XSetWindowAttributes pattr;

	get_mouse_position(&mousex, &mousey);

	bounddims.x = 0;
	bounddims.y = 0;
	bounddims.width = DisplayWidth(dsply, screen);
	bounddims.height = BARHEIGHT();

	constraint_win = XCreateWindow(dsply, root, bounddims.x, bounddims.y, bounddims.width, bounddims.height, 0, CopyFromParent, InputOnly, CopyFromParent, 0, &pattr);
	XMapWindow(dsply, constraint_win);

	if (!(XGrabPointer(dsply, root, False, MouseMask, GrabModeAsync, GrabModeAsync, constraint_win, None, CurrentTime) == GrabSuccess))
	{
		XDestroyWindow(dsply, constraint_win);
		return;
	}
	draw_menubar();
	update_menuitem(INT_MAX); // force initial highlight
	current_item = update_menuitem(x);
	do
	{
		XMaskEvent(dsply, MouseMask|KeyMask, &ev);
		switch (ev.type)
		{
			case MotionNotify:
				current_item = update_menuitem(ev.xmotion.x);
				break;
			case ButtonRelease:
				if (current_item != UINT_MAX)
				{
					fork_exec(menuitems[current_item].command);
				}
				break;
			case KeyPress:
				XPutBackEvent(dsply, &ev);
				break;
		}
	}
	while (ev.type != ButtonPress && ev.type != ButtonRelease && ev.type != KeyPress);

	redraw_taskbar();
	XUnmapWindow(dsply, constraint_win);
	XDestroyWindow(dsply, constraint_win);
	ungrab();
}
Ejemplo n.º 17
0
Bool recursively_find_motion_notify (int depth)
{
	XEvent junk_event;

	if (XCheckMaskEvent (dpy, 0xFFFFFFFF, &junk_event)) {
		XPutBackEvent (dpy, &junk_event);
		if (junk_event.type == MotionNotify)
			return True;
		if (depth > 0)
			return recursively_find_motion_notify (depth - 1);
	}
	return False;
}
Ejemplo n.º 18
0
static void eatExpose(void)
{
	XEvent event, foo;

	/* compress all expose events into a single one */

	if (XCheckMaskEvent(dpy, ExposureMask, &event)) {
		/* ignore other exposure events for this window */
		while (XCheckWindowEvent(dpy, event.xexpose.window, ExposureMask, &foo)) ;
		/* eat exposes for other windows */
		eatExpose();

		event.xexpose.count = 0;
		XPutBackEvent(dpy, &event);
	}
}
Ejemplo n.º 19
0
    bool x11EventFilter ( XEvent * event )
    {
        if(event->type == KeyPress || event->type == KeyRelease)
        {
            XKeyEvent* key = reinterpret_cast<XKeyEvent*> (event);

            bool autor = false;
            static uint curr_autorep = 0;
            if (event->type == KeyPress)
            {
                if (curr_autorep == event->xkey.keycode)
                {
                    autor = true;
                    curr_autorep = 0;
                }
            }
            else
            {
                // look ahead for auto-repeat
                XEvent nextpress;

                Display* dpy = QX11Info::display();

                // was this the last auto-repeater?
                x_auto_repeat_data auto_repeat_data;
                auto_repeat_data.keycode = event->xkey.keycode;
                auto_repeat_data.timestamp = event->xkey.time;

                auto_repeat_data.release = true;
                auto_repeat_data.error = false;
                if (XCheckIfEvent(dpy, &nextpress, &qt_keypress_scanner,
                                  (XPointer) &auto_repeat_data)) {
                    autor = true;
                    XPutBackEvent(dpy,&nextpress);
                }

                curr_autorep = autor ? event->xkey.keycode : 0;
            }

            if(!autor)
                m_mainwindow->keysActive(key->keycode, key->state, event->type == KeyPress);
        }

        return QApplication::x11EventFilter(event);
    }
Ejemplo n.º 20
0
int crt0_keypressed(void)
{

  XEvent report;

  while(XCheckMaskEvent(display,ExposureMask|StructureNotifyMask,&report))
  { 
     switch(report.type)
     {
	case Expose:

           if (xw_expose !=NULL) (*xw_expose)(report.xexpose.x,report.xexpose.y,
	       report.xexpose.width,report.xexpose.height);
	   break;
	case ConfigureNotify:
	   bgi_maxx=report.xconfigure.width-1;
	   bgi_maxy=report.xconfigure.height-1;		
           if (xw_expose !=NULL) (*xw_expose)(0,0,bgi_maxx,bgi_maxy);
           sizeChanged=1;		
     }

  }


	
  if( XCheckMaskEvent(display,ButtonPressMask|ButtonReleaseMask|KeyPressMask|
  VisibilityChangeMask| ResizeRedirectMask|PropertyChangeMask|ColormapChangeMask,
	    &report))
  {	   
	switch(report.type)
	{
	case KeyPress:
	case ButtonPress:
	case ButtonRelease:
		XPutBackEvent(display,&report);
		return 1;
	default:
	 return 0;	
	}

  } return sizeChanged;
}
Ejemplo n.º 21
0
void pen(const char *arg) {
    if (presenter_mode) fprintf(stdout,"PEN\n");
    XDefineCursor(dpy,win,None);
    XEvent ev;
    int x,y,nx,ny;
    char pw[3] = "  ";
    pw[0] = arg[0];
    pw[1] = arg[1];
    Colormap cmap = DefaultColormap(dpy,scr);
    XColor color;
    XAllocNamedColor(dpy,cmap,arg+3,&color,&color);
    XGCValues val;
    val.foreground = color.pixel;
    val.line_width = atoi(pw);
    val.cap_style = CapRound;
    GC pgc = XCreateGC(dpy,win,GCForeground|GCLineWidth|GCCapStyle,&val);
    for (;;) {
        while ( !XNextEvent(dpy,&ev) && ev.type!=ButtonPress && ev.type!=KeyPress );
        if (ev.type == KeyPress) {
            XPutBackEvent(dpy,&ev);
            break;
        }
        XGrabPointer(dpy,ev.xbutton.window,True,
                     PointerMotionMask | ButtonReleaseMask, GrabModeAsync,
                     GrabModeAsync,None,None,CurrentTime);
        x = ev.xbutton.x;
        y = ev.xbutton.y;
        while ( !XNextEvent(dpy,&ev) && ev.type != ButtonRelease) {
            nx = ev.xmotion.x;
            ny = ev.xmotion.y;
            XDrawLine(dpy,win,pgc,x,y,nx,ny);
            x = nx;
            y = ny;
            XFlush(dpy);
        }
        XUngrabPointer(dpy,CurrentTime);
    }
    XDefineCursor(dpy,win,invisible_cursor);
    /* force a redraw of the background in case pens went outside of the slide */
    white_muted = True;
}
Ejemplo n.º 22
0
i4_bool x11_shm_image_actual_class::copy_part_to_vram(x11_shm_extension_class * use,
													  i4_coord x, i4_coord y,
													  i4_coord x1, i4_coord y1,
													  i4_coord x2, i4_coord y2)
{
	XEvent ev;

	XSync(display,False);

	if (y1>y2 || x1>x2)
	{
		return i4_T;
	}


	if (use->need_sync_event)
	{
		XEvent ev;
		while (XCheckTypedEvent(display,use->shm_base+ShmCompletion,&ev)==False)
			XSync(display,False);


		use->need_sync_event=i4_F;
	}

	if (XCheckTypedEvent(display, ConfigureNotify,&ev)==False)
	{
		XShmPutImage(display,window,gc,im,x1,y1,x,y,x2-x1+1,y2-y1+1,True);
		XSync(display,False);
		use->need_sync_event=i4_T;
		return i4_T;
	}
	else     // screen size changed,  better wait till this event is handled cause put might be invalid
	{
		XPutBackEvent(display,&ev);
		return i4_F;
	}

}
Ejemplo n.º 23
0
static void zoom(cairo_t *ctx, cairo_surface_t *buf,
		cairo_surface_t *cbuf, Theme *q) {
	XEvent ev;
	double qe = q->e;
	int x1 = -1, y1, x2, y2;
	XDefineCursor(dpy, wshow, crosshair_cursor);
	while (!XNextEvent(dpy, &ev)) {
		if (ev.type == KeyPress) { XPutBackEvent(dpy, &ev); break; }
		else if (ev.type == ButtonPress && x1 < 0) {
			if (ev.xbutton.button == 1) {
				x1 = ev.xbutton.x;
				y1 = ev.xbutton.y;
			}
		}
		else if (ev.type == ButtonPress && x1 >= 0) {
			if (ev.xbutton.button == 1) {
				x2 = ev.xbutton.x;
				y2 = ev.xbutton.y;
				break;
			}
			else {
				x1 = -1;
			}
		}
		else if (ev.type == MotionNotify && x1 >= 0) {
			cairo_set_source_surface(ctx, cbuf, 0, 0);
			cairo_paint(ctx);
			cairo_set_source_rgba(ctx, q->R, q->G, q->B, q->A);
			cairo_rectangle(ctx, x1, y1, ev.xbutton.x - x1,
					ev.xbutton.y - y1);
			cairo_stroke(ctx);
			cairo_set_source_surface(show->target[0].ctx, buf, 0, 0);
			cairo_paint(show->target[0].ctx);
		}
	}
	zoom_rect(x1, y1, x2, y2);
}
Ejemplo n.º 24
0
/**
 * \brief This function is called when an Extension Event is received
 * and calls the corresponding callback functions for these events.
 */
void fgHandleExtensionEvents( XEvent* base_ev )
{
    XEvent std_ev;    /* standard single-pointer event to be added to the event queue */
    int i, button = 0;
    XGenericEventCookie* cookie = (XGenericEventCookie*)&(base_ev->xcookie);

    /* initialize the generic fields from base_ev */
    std_ev.xany = base_ev->xany;

    if ( XGetEventData( fgDisplay.pDisplay.Display, cookie ) && (cookie->type == GenericEvent) && (cookie->extension == xi_opcode) ) {

        XIDeviceEvent* event = (XIDeviceEvent*)(cookie->data);
        XIEnterEvent *evcross;
        /*printf("XI2 event type: %d - %d\n", cookie->evtype, event->type );*/

        SFG_Window* window = fgWindowByHandle( event->event );
        if (!window) return;

        switch (cookie->evtype) {
        case XI_Enter:
        case XI_Leave:
            evcross = (XIEnterEvent*)event;

            fgState.Modifiers = fgPlatformGetModifiers( evcross->mods.base );
            INVOKE_WCB( *window, MultiEntry, (
                event->deviceid,
                (event->evtype == XI_Enter ? GLUT_ENTERED : GLUT_LEFT)
            ));
            #if _DEBUG
            fgPrintXILeaveEvent((XILeaveEvent*)event);
            #endif

            /* Also process the standard crossing event */
            std_ev.type = evcross->evtype == XI_Enter ? EnterNotify : LeaveNotify;
            std_ev.xcrossing.window = evcross->event;
            std_ev.xcrossing.root = evcross->root;
            std_ev.xcrossing.subwindow = evcross->child;
            std_ev.xcrossing.x = evcross->event_x;
            std_ev.xcrossing.y = evcross->event_y;
            std_ev.xcrossing.x_root = evcross->root_x;
            std_ev.xcrossing.y_root = evcross->root_y;
            std_ev.xcrossing.mode = evcross->mode;
            std_ev.xcrossing.detail = evcross->detail;
            std_ev.xcrossing.same_screen = evcross->same_screen;
            std_ev.xcrossing.focus = evcross->focus;
            std_ev.xcrossing.state = BUTTON_MASK(*(unsigned int*)evcross->buttons.mask);

            XPutBackEvent(fgDisplay.pDisplay.Display, &std_ev);
            break;

        case XI_ButtonPress:
        case XI_ButtonRelease:
            fgState.Modifiers = fgPlatformGetModifiers( event->mods.base );
            INVOKE_WCB( *window, MultiButton, (
                event->deviceid,
                event->event_x,
                event->event_y,
                event->detail-1,
                (event->evtype == XI_ButtonPress ? GLUT_DOWN : GLUT_UP)
            ));

            /* Also process the standard button event */
            std_ev.type = event->evtype == XI_ButtonPress ? ButtonPress : ButtonRelease;
            std_ev.xbutton.window = event->event;
            std_ev.xbutton.root = event->root;
            std_ev.xbutton.subwindow = event->child;
            std_ev.xbutton.x = event->event_x;
            std_ev.xbutton.y = event->event_y;
            std_ev.xbutton.x_root = event->root_x;
            std_ev.xbutton.y_root = event->root_y;
            std_ev.xbutton.state = event->mods.base;
            std_ev.xbutton.button = event->detail;

            XPutBackEvent(fgDisplay.pDisplay.Display, &std_ev);
            break;

        case XI_Motion:
            fgState.Modifiers = fgPlatformGetModifiers( event->mods.base );
            for (i = 0; i < event->buttons.mask_len; i++) {
                if (event->buttons.mask[i]) {
                    button = 1;
                }
            }
            if (button) {
                INVOKE_WCB( *window, MultiMotion,  ( event->deviceid, event->event_x, event->event_y ) );
            } else {
                INVOKE_WCB( *window, MultiPassive, ( event->deviceid, event->event_x, event->event_y ) );
            }
            #if _DEBUG
            fgPrintXIDeviceEvent(event);
            #endif

            /* Also process the standard motion event */
            std_ev.type = MotionNotify;
            std_ev.xmotion.window = event->event;
            std_ev.xmotion.root = event->root;
            std_ev.xmotion.subwindow = event->child;
            std_ev.xmotion.time = event->time;
            std_ev.xmotion.x = event->event_x;
            std_ev.xmotion.y = event->event_y;
            std_ev.xmotion.x_root = event->root_x;
            std_ev.xmotion.y_root = event->root_y;
            std_ev.xmotion.state = BUTTON_MASK(*(unsigned int*)event->buttons.mask);
            std_ev.xmotion.is_hint = NotifyNormal;

            XPutBackEvent(fgDisplay.pDisplay.Display, &std_ev);
            break;

        default:
            #if _DEBUG
            fgWarning( "Unknown XI2 device event:" );
            fgPrintXIDeviceEvent( event );
            #endif
            break;
        }
        fgState.Modifiers = INVALID_MODIFIERS;
    }
    XFreeEventData( fgDisplay.pDisplay.Display, cookie );
}
Ejemplo n.º 25
0
int
XMenuActivate(
    register Display *display,		/* Display to put menu on. */
    register XMenu *menu,		/* Menu to activate. */
    int *p_num,				/* Pane number selected. */
    int *s_num,				/* Selection number selected. */
    int x_pos,				/* X coordinate of menu position. */
    int y_pos,				/* Y coordinate of menu position. */
    unsigned int event_mask,		/* Mouse button event mask. */
    char **data,			/* Pointer to return data value. */
    void (*help_callback) (char const *, int, int)) /* Help callback.  */
{
    int status;				/* X routine call status. */
    int orig_x;				/* Upper left menu origin X coord. */
    int orig_y;				/* Upper left menu origin Y coord. */
    int ret_val;			/* Return value. */

    register XMPane *p_ptr;		/* Current XMPane. */
    register XMPane *event_xmp;		/* Event XMPane pointer. */
    register XMPane *cur_p;		/* Current pane. */
    register XMSelect *cur_s;		/* Current selection. */
    XMWindow *event_xmw;		/* Event XMWindow pointer. */
    XEvent event;			/* X input event. */
    XEvent peek_event;			/* X input peek ahead event. */

    Bool selection = False;		/* Selection has been made. */
    Bool forward = True;		/* Moving forward in the pane list. */

    Window root, child;
    int root_x, root_y, win_x, win_y;
    unsigned int mask;
    KeySym keysym;

    /*
     * Define and allocate a foreign event queue to hold events
     * that don't belong to XMenu.  These events are later restored
     * to the X event queue.
     */
    typedef struct _xmeventque {
	XEvent event;
	struct _xmeventque *next;
    } XMEventQue;

    XMEventQue *feq = NULL;    		/* Foreign event queue. */
    XMEventQue *feq_tmp;		/* Foreign event queue temporary. */

    /*
     * If there are no panes in the menu then return failure
     * because the menu is not initialized.
     */
    if (menu->p_count == 0) {
	_XMErrorCode = XME_NOT_INIT;
	return(XM_FAILURE);
    }

    /*
     * Find the desired current pane.
     */
    cur_p = _XMGetPanePtr(menu, *p_num);
    if (cur_p == NULL) {
	return(XM_FAILURE);
    }
    cur_p->activated = cur_p->active;

    /*
     * Find the desired current selection.
     * If the current selection index is out of range a null current selection
     * will be assumed and the cursor will be placed in the current pane
     * header.
     */
    cur_s = _XMGetSelectionPtr(cur_p, *s_num);

    /*
     * Compute origin of menu so that cursor is in
     * Correct pane and selection.
     */
    _XMTransToOrigin(display,
		     menu,
		     cur_p, cur_s,
		     x_pos, y_pos,
		     &orig_x, &orig_y);
    menu->x_pos = orig_x;	/* Store X and Y coords of menu. */
    menu->y_pos = orig_y;

    if (XMenuRecompute(display, menu) == XM_FAILURE) {
	return(XM_FAILURE);
    }

    /*
     * Flush the window creation queue.
     * This batches all window creates since lazy evaluation
     * is more efficient than individual evaluation.
     * This routine also does an XFlush().
     */
    if (_XMWinQueFlush(display, menu, cur_p, cur_s) == _FAILURE) {
	return(XM_FAILURE);
    }

    /*
     * Make sure windows are in correct order (in case we were passed
     * an already created menu in incorrect order.)
     */
    for(p_ptr = menu->p_list->next; p_ptr != cur_p; p_ptr = p_ptr->next)
	XRaiseWindow(display, p_ptr->window);
    for(p_ptr = menu->p_list->prev; p_ptr != cur_p->prev; p_ptr = p_ptr->prev)
	XRaiseWindow(display, p_ptr->window);

    /*
     * Make sure all selection windows are mapped.
     */
    for (
	p_ptr = menu->p_list->next;
	p_ptr != menu->p_list;
	p_ptr = p_ptr->next
    ){
	XMapSubwindows(display, p_ptr->window);
    }

    /*
     * Synchronize the X buffers and the event queue.
     * From here on, all events in the queue that don't belong to
     * XMenu are sent back to the application via an application
     * provided event handler or discarded if the application has
     * not provided an event handler.
     */
    XSync(display, 0);

    /*
     * Grab the mouse for menu input.
     */

    status = XGrabPointer(
			  display,
			  menu->parent,
			  True,
			  event_mask,
			  GrabModeAsync,
			  GrabModeAsync,
			  None,
			  menu->mouse_cursor,
			  CurrentTime
			  );
    if (status == Success && x_menu_grab_keyboard)
      {
        status = XGrabKeyboard (display,
                                menu->parent,
                                False,
                                GrabModeAsync,
                                GrabModeAsync,
                                CurrentTime);
        if (status != Success)
          XUngrabPointer(display, CurrentTime);
      }

    if (status == _X_FAILURE) {
	_XMErrorCode = XME_GRAB_MOUSE;
	return(XM_FAILURE);
    }

    /*
     * Map the menu panes.
     */
    XMapWindow(display, cur_p->window);
    for (p_ptr = menu->p_list->next;
	 p_ptr != cur_p;
	 p_ptr = p_ptr->next)
      XMapWindow(display, p_ptr->window);
    for (p_ptr = cur_p->next;
	 p_ptr != menu->p_list;
	 p_ptr = p_ptr->next)
      XMapWindow(display, p_ptr->window);

    XRaiseWindow(display, cur_p->window);	/* Make sure current */
						/* pane is on top. */

    cur_s = NULL;			/* Clear current selection. */

    /*
     * Begin event processing loop.
     */
    while (1) {
        if (wait_func) (*wait_func) (wait_data);
	XNextEvent(display, &event);	/* Get next event. */
	switch (event.type) {		/* Dispatch on the event type. */
    case Expose:
	    event_xmp = (XMPane *)XLookUpAssoc(display,
					       menu->assoc_tab,
					       event.xexpose.window);
	    if (event_xmp == NULL) {
		/*
		 * If AEQ mode is enabled then queue the event.
		 */
		if (menu->aeq) {
		    feq_tmp = (XMEventQue *)malloc(sizeof(XMEventQue));
		    if (feq_tmp == NULL) {
			_XMErrorCode = XME_CALLOC;
			return(XM_FAILURE);
		    }
		    feq_tmp->event = event;
		    feq_tmp->next = feq;
		    feq = feq_tmp;
		}
		else if (_XMEventHandler) (*_XMEventHandler)(&event);
		break;
	    }
	    if (event_xmp->activated) {
		XSetWindowBackground(display,
				     event_xmp->window,
				     menu->bkgnd_color);
	    }
	    else {
		XSetWindowBackgroundPixmap(display,
					   event_xmp->window,
					   menu->inact_pixmap);
	    }
	    _XMRefreshPane(display, menu, event_xmp);
	    break;
    case EnterNotify:
	    /*
	     * First wait a small period of time, and see
	     * if another EnterNotify event follows hard on the
	     * heels of this one. i.e., the user is simply
	     * "passing through". If so, ignore this one.
	     */

	    event_xmw = (XMWindow *)XLookUpAssoc(display,
						 menu->assoc_tab,
						 event.xcrossing.window);
	    if (event_xmw == NULL) break;
	    if (event_xmw->type == SELECTION) {
		/*
		 * We have entered a selection.
		 */
		/* if (XPending(display) == 0) usleep(150000); */
		if (XPending(display) != 0) {
		    XPeekEvent(display, &peek_event);
		    if(peek_event.type == LeaveNotify) {
			break;
		    }
		}
		cur_s = (XMSelect *)event_xmw;
		help_callback (cur_s->help_string,
			       cur_p->serial, cur_s->serial);

		/*
		 * If the pane we are in is active and the
		 * selection entered is active then activate
		 * the selection.
		 */
		if (cur_p->active && cur_s->active > 0) {
		    cur_s->activated = 1;
		    _XMRefreshSelection(display, menu, cur_s);
		}
	    }
	    else {
		/*
		 * We have entered a pane.
		 */
		/* if (XPending(display) == 0) usleep(150000); */
		if (XPending(display) != 0) {
		    XPeekEvent(display, &peek_event);
		    if (peek_event.type == EnterNotify) break;
		}
		XQueryPointer(display,
			      menu->parent,
			      &root, &child,
			      &root_x, &root_y,
			      &win_x, &win_y,
			      &mask);
		event_xmp = (XMPane *)XLookUpAssoc(display,
						   menu->assoc_tab,
						   child);
		if (event_xmp == NULL) break;
		if (event_xmp == cur_p) break;
		if (event_xmp->serial > cur_p->serial) forward = True;
		else forward = False;
		p_ptr = cur_p;
		while (p_ptr != event_xmp) {
		    if (forward) p_ptr = p_ptr->next;
		    else p_ptr = p_ptr->prev;
		    XRaiseWindow(display, p_ptr->window);
		}
		if (cur_p->activated) {
		    cur_p->activated = False;
		    XSetWindowBackgroundPixmap(display,
					       cur_p->window,
					       menu->inact_pixmap);
		    _XMRefreshPane(display, menu, cur_p);
		}
		if (event_xmp->active) event_xmp->activated = True;
#if 1
		/*
		 * i suspect the we don't get an EXPOSE event when backing
		 * store is enabled; the menu windows content is probably
		 * not drawn in when it should be in that case.
		 * in that case, this is probably an ugly fix!
		 * i hope someone more familiar with this code would
		 * take it from here.  -- [email protected].
		 */
		XSetWindowBackground(display,
				     event_xmp->window,
				     menu->bkgnd_color);
		_XMRefreshPane(display, menu, event_xmp);
#endif
		cur_p = event_xmp;
	    }
	    break;
    case LeaveNotify:
	    event_xmw = (XMWindow *)XLookUpAssoc(
						 display,
						 menu->assoc_tab,
						 event.xcrossing.window
						 );
	    if (event_xmw == NULL) break;
	    if(cur_s == NULL) break;

	    /*
	     * If the current selection was activated then
	     * deactivate it.
	     */
	    if (cur_s->activated) {
		cur_s->activated = False;
		_XMRefreshSelection(display, menu, cur_s);
	    }
	    cur_s = NULL;
	    break;

    case ButtonPress:
    case ButtonRelease:
		*p_num = cur_p->serial;
		/*
		 * Check to see if there is a current selection.
		 */
		if (cur_s != NULL) {
		    /*
		     * Set the selection number to the current selection.
		     */
		    *s_num = cur_s->serial;
		    /*
		     * If the current selection was activated then
		     * we have a valid selection otherwise we have
		     * an inactive selection.
		     */
		    if (cur_s->activated) {
			*data = cur_s->data;
			ret_val = XM_SUCCESS;
		    }
		    else {
			ret_val = XM_IA_SELECT;
		    }
		}
		else {
		    /*
		     * No selection was current.
		     */
		    ret_val = XM_NO_SELECT;
		}
		selection = True;
		break;
        case KeyPress:
        case KeyRelease:
                keysym = XLookupKeysym (&event.xkey, 0);

                /* Pop down on C-g and Escape.  */
                if ((keysym == XK_g && (event.xkey.state & ControlMask) != 0)
                    || keysym == XK_Escape) /* Any escape, ignore modifiers.  */
                  {
                    ret_val = XM_NO_SELECT;
                    selection = True;
                  }
               break;
	    default:
		/*
		 * If AEQ mode is enabled then queue the event.
		 */
		if (menu->aeq) {
		    feq_tmp = (XMEventQue *)malloc(sizeof(XMEventQue));
		    if (feq_tmp == NULL) {
			_XMErrorCode = XME_CALLOC;
			return(XM_FAILURE);
		    }
		    feq_tmp->event = event;
		    feq_tmp->next = feq;
		    feq = feq_tmp;
		}
		else if (_XMEventHandler) (*_XMEventHandler)(&event);
	}
	/*
	 * If a selection has been made, break out of the event loop.
	 */
	if (selection == True) break;
    }

    /*
     * Unmap the menu.
     */
    for ( p_ptr = menu->p_list->next;
	 p_ptr != menu->p_list;
	 p_ptr = p_ptr->next)
      {
	  XUnmapWindow(display, p_ptr->window);
      }

    /*
     * Ungrab the mouse.
     */
    XUngrabPointer(display, CurrentTime);
    XUngrabKeyboard(display, CurrentTime);

    /*
     * Restore bits under where the menu was if we managed
     * to save them and free the pixmap.
     */

    /*
     * If there is a current selection deactivate it.
     */
    if (cur_s != NULL) cur_s->activated = 0;

    /*
     * Deactivate the current pane.
     */
    cur_p->activated = 0;
    XSetWindowBackgroundPixmap(display, cur_p->window, menu->inact_pixmap);

    /*
     * Synchronize the X buffers and the X event queue.
     */
    XSync(display, 0);

    /*
     * Dispatch any events remaining on the queue.
     */
    while (QLength(display)) {
	/*
	 * Fetch the next event.
	 */
	XNextEvent(display, &event);

	/*
	 * Discard any events left on the queue that belong to XMenu.
	 * All others are held and then returned to the event queue.
	 */
	switch (event.type) {
	    case Expose:
	    case EnterNotify:
	    case LeaveNotify:
	    case ButtonPress:
	    case ButtonRelease:
		/*
		 * Does this event belong to one of XMenu's windows?
		 * If so, discard it and process the next event.
		 * If not fall through and treat it as a foreign event.
		 */
		event_xmp = (XMPane *)XLookUpAssoc(
						   display,
						   menu->assoc_tab,
						   event.xbutton.window
						   );
		if (event_xmp != NULL) continue;
	    default:
		/*
		 * This is a foreign event.
		 * Queue it for later return to the X event queue.
		 */
		feq_tmp = (XMEventQue *)malloc(sizeof(XMEventQue));
		if (feq_tmp == NULL) {
		    _XMErrorCode = XME_CALLOC;
		    return(XM_FAILURE);
		}
		feq_tmp->event = event;
		feq_tmp->next = feq;
		feq = feq_tmp;
	    }
    }
    /*
     * Return any foreign events that were queued to the X event queue.
     */
    while (feq != NULL) {
	feq_tmp = feq;
	XPutBackEvent(display, &feq_tmp->event);
	feq = feq_tmp->next;
	free((char *)feq_tmp);
    }

    wait_func = 0;

    /*
     * Return successfully.
     */
    _XMErrorCode = XME_NO_ERROR;
    return(ret_val);

}
Ejemplo n.º 26
0
/*
 * Attempt to read bytes from the mouse and interpret them.
 * Returns -1 on error, 0 if either no bytes were read or not enough
 * was read for a complete state, or 1 if the new state was read.
 * When a new state is read, the current buttons and x and y deltas
 * are returned.  This routine does not block.
 */
static int
X11_Read(MWCOORD *dx, MWCOORD *dy, MWCOORD *dz, int *bp)
{
    static int noevent_count = 0;
    XEvent ev;
    int events = 0;
    long mask = /* x11_event_mask | */
#ifdef USE_EXPOSURE
      ButtonPressMask | ButtonReleaseMask | PointerMotionMask | ExposureMask;
#else
      ButtonPressMask | ButtonReleaseMask | PointerMotionMask;
#endif

    while (XCheckMaskEvent(x11_dpy, mask, &ev)) {
	if (ev.type == MotionNotify) {
	    if (ev.xmotion.window == x11_win) {
		int button = 0;
		*dx = ev.xmotion.x;
		*dy = ev.xmotion.y;
		*dz = 0;
		if (ev.xmotion.state & Button1Mask)
		    button |= MWBUTTON_L;
		if (ev.xmotion.state & Button2Mask)
		    button |= MWBUTTON_M;
		if (ev.xmotion.state & Button3Mask)
		    button |= MWBUTTON_R;
		*bp = button;
		events++;
	    }
	}
	else if (ev.type == ButtonPress) {
	    if (ev.xbutton.window == x11_win) {
	        int button = 0;
		
		/* Get pressed button */
	    	if(ev.xbutton.button == 1)
			button = MWBUTTON_L;
		else if(ev.xbutton.button == 2)
			button = MWBUTTON_M;
		else if(ev.xbutton.button == 3)
			button = MWBUTTON_R;

		/* Get any other buttons that might be already held */
		if (ev.xbutton.state & Button1Mask)
		    button |= MWBUTTON_L;
		if (ev.xbutton.state & Button2Mask)
		    button |= MWBUTTON_M;
		if (ev.xbutton.state & Button3Mask)
		    button |= MWBUTTON_R;
		
/*		printf("!Pressing button: 0x%x, state: 0x%x, button: 0x%x\n",
			button,ev.xbutton.state, ev.xbutton.button);*/
		*bp = button;
		*dx = ev.xbutton.x;
		*dy = ev.xbutton.y;
		*dz = 0;
		events++;
	    }
	}
	else if (ev.type == ButtonRelease) {
	    if (ev.xbutton.window == x11_win) {
	        int button = 0;
		int released = 0;
	
		/* Get released button */
	    	if(ev.xbutton.button == 1)
			released = MWBUTTON_L;
		else if(ev.xbutton.button == 2)
			released = MWBUTTON_M;
		else if(ev.xbutton.button == 3)
			released = MWBUTTON_R;
		
		/* Get any other buttons that might be already held */
		if (ev.xbutton.state & Button1Mask)
		    button |= MWBUTTON_L;
		if (ev.xbutton.state & Button2Mask)
		    button |= MWBUTTON_M;
		if (ev.xbutton.state & Button3Mask)
		    button |= MWBUTTON_R;
	
		/* We need to remove the released button from the button mask*/
		button &= ~released;

		/*printf("!Releasing button: 0x%x, state: 0x%x, button: 0x%x\n",
			button,ev.xbutton.state, ev.xbutton.button);*/

		*bp = button;
		*dx = ev.xbutton.x;
		*dy = ev.xbutton.y;
		*dz = 0;
		events++;
	    }
	}
	else {
	    x11_handle_event(&ev);
	}
    }
    if (events == 0) {
	/* after a bunch of consecutive noevent calls here
           (meaning select() says there's something to read but nothing
            is returned......), force an event read (which will
            most likely terminate the connection) */
	if (++noevent_count >= 50) {
            while(XNextEvent(x11_dpy, &ev)) {
                /* if we return, then we got an event...put it back
                   so we can properly process it next time through */
                XPutBackEvent(x11_dpy, &ev);
            }
            noevent_count = 0;
	}
	return 0;
    }
    noevent_count = 0;
    return 2;		/* absolute position returned*/
}
Ejemplo n.º 27
0
         short WPgrid_dialog(DBint grw_id)

/*      The grid dialogue.
 *
 *      In: grw_id = ID of WPGWIN that called us.
 *
 *      (C)2007-03-12 J.Kjellander
 *
 ******************************************************!*/

  {
   char     rubrik[81],close[81],help[81],edit[81],pos[81],
            res[81],show[81],hide[81],move[81],movett[81],
            edittt[81],showtt[81],hidett[81],bs1[81],bs2[81],
            closett[81],helptt[81];
   char    *typ[20];
   int      bh,wm_x1,wm_y1,wm_x2,wm_y2,butlen,bl1,bl2,actfunc_org;
   short    status,main_dx,main_dy,alt_x,alt_y,butlen1,butlen2,ly,lm;
   DBint    iwin_id,move_id,edit_id,show_id,hide_id,close_id,
            help_id,but_id;
   unsigned int dum1,dum2;
   DBVector newpos;
   WPWIN   *winptr;
   WPIWIN  *iwinpt;
   WPBUTT  *butptr;
   WPGWIN  *gwinpt;
   XEvent   event;
   XrmValue value;

/*
***Set actfunc during user action, see IG/include/futab.h.
*/
   actfunc_org = actfunc;
   actfunc = 103;
/*
***Is this the first time this function is called ?
***Initial window position.
*/
   if ( premiere )
     {
     iwin_x = iwin_y = 5;

     if ( XrmGetResource(xresDB,"varkon.grid.geometry",
                                "Varkon.Grid.Geometry",
                                 typ,&value) ) 
       XParseGeometry((char *)value.addr,&iwin_x,&iwin_y,&dum1,&dum2);

     premiere = FALSE;
     }
/*
***Get a C ptr to the graphical window that called us.
*/
   gwinpt = (WPGWIN *)wpwtab[grw_id].ptr;
/*
***During user interaction the dialogue window may get deleted
***and created again with new contents. This is where we start
***recreating a new instance.
*/
start:

/*
***Window title, position, resolution, move, edit, show, hide,
***close and help from the ini-file.
*/
   if ( !WPgrst("varkon.grid.title",rubrik) )           strcpy(rubrik,"Grid");
   if ( !WPgrst("varkon.grid.position.text",pos) )      strcpy(pos,"Position");
   if ( !WPgrst("varkon.grid.resolution.text",res) )    strcpy(res,"Resolution");
   if ( !WPgrst("varkon.grid.show.text",show) )         strcpy(show,"Show");
   if ( !WPgrst("varkon.grid.show.tooltip",showtt) )    strcpy(showtt,"");
   if ( !WPgrst("varkon.grid.hide.text",hide) )         strcpy(hide,"Hide");
   if ( !WPgrst("varkon.grid.hide.tooltip",hidett) )    strcpy(hidett,"");
   if ( !WPgrst("varkon.grid.move.text",move) )         strcpy(move,"Move");
   if ( !WPgrst("varkon.grid.move.tooltip",movett) )    strcpy(movett,"");
   if ( !WPgrst("varkon.grid.edit.text",edit) )         strcpy(edit,"Edit");
   if ( !WPgrst("varkon.grid.edit.tooltip",edittt) )    strcpy(edittt,"");
   if ( !WPgrst("varkon.input.close",close) )           strcpy(close,"Close");
   if ( !WPgrst("varkon.input.close.tooltip",closett) ) strcpy(closett,"");
   if ( !WPgrst("varkon.input.help",help) )             strcpy(help,"Help");
   if ( !WPgrst("varkon.input.help.tooltip",helptt) )   strcpy(helptt,"");
/*
***What is the 1.2*length of the longest text ?
***Don't include the title, it will fit anyhow.
*/
   butlen1 = 0;
   if ( WPstrl(pos)    > butlen1 ) butlen1 = WPstrl(pos);
   if ( WPstrl(res)    > butlen1 ) butlen1 = WPstrl(res);
   if ( WPstrl(move)   > butlen1 ) butlen1 = WPstrl(move);
   if ( WPstrl(edit)   > butlen1 ) butlen1 = WPstrl(edit);
   if ( WPstrl(show)   > butlen1 ) butlen1 = WPstrl(show);
   if ( WPstrl(hide)   > butlen1 ) butlen1 = WPstrl(hide);
   butlen1 *= 1.2;

   butlen2 = 0;
   if ( WPstrl(close)  > butlen2 ) butlen2 = WPstrl(close);
   if ( WPstrl(help)   > butlen2 ) butlen2 = WPstrl(help);
   butlen2 *= 1.8;
/*
***Calculate outside air (ly), button height (bh) and air between (lm).
*/
   ly = (short)(1.2*WPstrh());
   bh = (short)(1.8*WPstrh());
   lm = (short)(0.8*WPstrh());
/*
***Calculate the window size in X-direction.
*/
   main_dx = ly + butlen1 + ly + ly + butlen1 + ly;
/*
***Calculate the window size in Y-direction.
*/
   main_dy = ly + bh + lm + bh + 0 + bh + lm + bh + bh + bh + bh + bh + bh + ly;
/*
***Create the dialogue window as a WPIWIN.
*/
   WPwciw((short)iwin_x,(short)iwin_y,main_dx,main_dy,rubrik,&iwin_id);
/*
***Get a C-ptr to the WPIWIN.
*/
   winptr = WPwgwp((wpw_id)iwin_id);
   iwinpt = (WPIWIN *)winptr->ptr;
/*
***A vertical line.
*/
   alt_x  = ly + butlen1 + ly;
   alt_y  = ly + lm;
   WPcreate_3Dline(iwin_id,alt_x,alt_y,alt_x,alt_y + 4*bh + 2*ly - 2*lm);
/*
***Position and resolution texts.
*/
   alt_x  = ly;
   alt_y  = ly;
   WPcrlb((wpw_id)iwin_id,alt_x,alt_y,butlen1,bh,pos,&but_id);

   alt_x  = ly + butlen1 + ly + ly;
   WPcrlb((wpw_id)iwin_id,alt_x,alt_y,butlen1,bh,res,&but_id);
/*
***X, Y, DX and DY texts.
*/
   sprintf(bs1,"X = %g",gwinpt->grid_x);
   bl1 = WPstrl(bs1);
   sprintf(bs2,"Y = %g",gwinpt->grid_y);
   bl2 = WPstrl(bs2);
   if ( bl1 > bl2 ) butlen = bl1;
   else             butlen = bl2;

   alt_x  = (ly + butlen1 + ly - butlen)/2;
   alt_y  = ly + bh + lm;
   WPcrlb((wpw_id)iwin_id,alt_x,alt_y,bl1,bh,bs1,&but_id);

   alt_y  = ly + bh + lm + bh;
   WPcrlb((wpw_id)iwin_id,alt_x,alt_y,bl2,bh,bs2,&but_id);

   sprintf(bs1,"DX = %g",gwinpt->grid_dx);
   bl1 = WPstrl(bs1);
   sprintf(bs2,"DY = %g",gwinpt->grid_dy);
   bl2 = WPstrl(bs2);
   if ( bl1 > bl2 ) butlen = bl1;
   else             butlen = bl2;

   alt_x  = ly + ly + butlen1 + (ly + butlen1 + ly - butlen)/2;
   alt_y  = ly + bh + lm;
   WPcrlb((wpw_id)iwin_id,alt_x,alt_y,bl1,bh,bs1,&but_id);

   alt_y  = ly + bh + lm + bh;
   WPcrlb((wpw_id)iwin_id,alt_x,alt_y,bl2,bh,bs2,&but_id);
/*
***Move and edit.
*/
   alt_x  = ly;
   alt_y += bh + lm;
   status = WPcrpb((wpw_id)iwin_id,alt_x,alt_y,butlen1,bh,(short)2,
                           move,move,"",WP_BGND2,WP_FGND,&move_id);
   butptr = (WPBUTT *)iwinpt->wintab[move_id].ptr;
   strcpy(butptr->tt_str,movett);

   alt_x  = ly + butlen1 + ly + ly;
   status = WPcrpb((wpw_id)iwin_id,alt_x,alt_y,butlen1,bh,(short)2,
                           edit,edit,"",WP_BGND2,WP_FGND,&edit_id);
   butptr = (WPBUTT *)iwinpt->wintab[edit_id].ptr;
   strcpy(butptr->tt_str,edittt);
/*
***Show and hide.
*/
   alt_x  = ly;
   alt_y  += bh + bh;
   status = WPcrpb((wpw_id)iwin_id,alt_x,alt_y,butlen1,bh,(short)2,
                           show,show,"",WP_BGND2,WP_FGND,&show_id);
   butptr = (WPBUTT *)iwinpt->wintab[show_id].ptr;
   strcpy(butptr->tt_str,showtt);

   alt_x  = ly + butlen1 + ly + ly;
   status = WPcrpb((wpw_id)iwin_id,alt_x,alt_y,butlen1,bh,(short)2,
                           hide,hide,"",WP_BGND2,WP_FGND,&hide_id);
   butptr = (WPBUTT *)iwinpt->wintab[hide_id].ptr;
   strcpy(butptr->tt_str,hidett);
/*
***A horizontal line.
*/
   alt_x  = main_dx/8;
   alt_y  += bh + bh;
   WPcreate_3Dline(iwin_id,alt_x,alt_y,alt_x + 6*main_dx/8,alt_y);
/*
***Close and help.
*/
   alt_x  = ly;
   alt_y += bh;
   status = WPcrpb((wpw_id)iwin_id,alt_x,alt_y,butlen2,bh,(short)3,
                           close,close,"",WP_BGND2,WP_FGND,&close_id);
   butptr = (WPBUTT *)iwinpt->wintab[close_id].ptr;
   strcpy(butptr->tt_str,closett);

   alt_x  = main_dx - ly - butlen2;
   status = WPcrpb((wpw_id)iwin_id,alt_x,alt_y,butlen2,bh,(short)2,
                           help,help,"",WP_BGND2,WP_FGND,&help_id);
   butptr = (WPBUTT *)iwinpt->wintab[help_id].ptr;
   strcpy(butptr->tt_str,helptt);
/*
***Show the dialogue.
*/
   WPwshw(iwin_id);
   XRaiseWindow(xdisp,iwinpt->id.x_id);
/*
***Where did it actually get positioned ?
***This code copied from WPmsip().
*/
   XWindowEvent(xdisp,iwinpt->id.x_id,ExposureMask,&event);
   XPutBackEvent(xdisp,&event);
   WPgtwp(iwinpt->id.x_id,&wm_x1,&wm_y1);
/*
***Wait for action. SMBPOSM is not an issue in this situation.
*/
   status = 0;
loop:
   if ( WPwwtw(iwin_id,SLEVEL_V3_INP,&but_id) == SMBPOSM ) goto loop;
/*
***Move button.
*/
   if ( but_id == move_id )
     {
     WPaddmess_mcwin(IGgtts(44),WP_PROMPT);
     status = IGcpov(&newpos);
     WPerhg();    
     IGrsma();
     if ( status == 0 )
       {
       WPdelete_grid(grw_id);
       gwinpt->grid_x = newpos.x_gm;
       gwinpt->grid_y = newpos.y_gm;
       WPdraw_grid(grw_id);
       goto update;
       }
     else goto loop;
     }
/*
***Edit button.
*/
   else if ( but_id == edit_id )
     {
     status = get_resolution(gwinpt,&newpos.x_gm,&newpos.y_gm);
     if ( status == 0 )
       {
       WPdelete_grid(grw_id);
       gwinpt->grid_dx = newpos.x_gm;
       gwinpt->grid_dy = newpos.y_gm;
       WPdraw_grid(grw_id);
       goto update;
       }
     else goto loop;
     }
/*
***Show button.
*/
   else if ( but_id == show_id )
     {
     WPgrid_on(grw_id);
     WPdraw_grid(grw_id);
     goto loop;
     }
/*
**Hide button.
*/
   else if ( but_id == hide_id )
     {
     WPdelete_grid(grw_id);
     WPgrid_off(grw_id);
     goto loop;
     }
/*
***Close button.
*/
   else if ( but_id == close_id )
     {
     status = 0;
     goto exit;
     }
/*
***Help button.
*/
   else if ( but_id == help_id )
     {
     IGhelp();
     goto loop;
     }
/*
***Unknown event, should not happen.
*/
   else
     {
     WPbell();
     goto loop;
     }
/*
***A view was added or removed so we need to update the window.
***Before deleting it, update the variables for it's current position.
*/
update:
   WPgtwp(iwinpt->id.x_id,&wm_x2,&wm_y2);
   iwin_x = iwin_x + wm_x2 - wm_x1;
   iwin_y = iwin_y + wm_y2 - wm_y1;
   WPwdel(iwin_id);
   goto start;
/*
***Time to exit. Reset global actfunc. Remeber current position.
*/
exit:
   actfunc = actfunc_org;
   WPgtwp(iwinpt->id.x_id,&wm_x2,&wm_y2);
   iwin_x = iwin_x + wm_x2 - wm_x1;
   iwin_y = iwin_y + wm_y2 - wm_y1;
   WPwdel(iwin_id);

   return(status);
 }
Ejemplo n.º 28
0
void QX11Data::motifdndHandle(QWidget *widget, const XEvent * xe, bool /* passive */)
{
    XEvent event = *xe;
    XClientMessageEvent cm ;
    DndData dnd_data ;
    char receiver ;

    if (!(DndParseClientMessage ((XClientMessageEvent*)&event,
                                 &dnd_data, &receiver))) {
        return;
    }

    switch (dnd_data.reason) {

    case DND_DRAG_MOTION:
        {
            QPoint p = widget->mapFromGlobal(QPoint(dnd_data.x, dnd_data.y));
            QWidget *c = widget->childAt(p);

            if (!c || !c->acceptDrops()) {
                // not over a drop site
                if (dropWidget) {
                    QDragLeaveEvent dragLeaveEvent;
                    QApplication::sendEvent(dropWidget, &dragLeaveEvent);

                    dropWidget = 0;
                    lastAcceptedAction = Qt::IgnoreAction;

                    dnd_data.reason = DND_DROP_SITE_LEAVE;
                    dnd_data.time = X11->time;
                    DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
                    XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm) ;
                } else {
                    dnd_data.reason = DND_DRAG_MOTION;
                    dnd_data.status = DND_NO_DROP_SITE;
                    dnd_data.time = X11->time;
                    dnd_data.operation = DND_NOOP;
                    dnd_data.operations = DND_NOOP;
                    DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
                    XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm) ;
                }
            } else {
                Q_ASSERT(c != 0);
                p = c->mapFrom(widget, p);

                if (dropWidget != c) {
                    if (dropWidget) {
                        QDragLeaveEvent le;
                        QApplication::sendEvent(dropWidget, &le);
                    }

                    dropWidget = c;
                    lastAcceptedAction = Qt::IgnoreAction;

                    const Qt::DropActions possibleActions =
                        DndOperationsToQtDropActions(dnd_data.operations);
                    QDragEnterEvent de(p, possibleActions, QDragManager::self()->dropData,
                                       QApplication::mouseButtons(), QApplication::keyboardModifiers());
                    QApplication::sendEvent(dropWidget, &de);

                    dnd_data.reason = DND_DROP_SITE_ENTER;
                    dnd_data.time = X11->time;
                    if (de.isAccepted()) {
                        lastAcceptedAction = de.dropAction();

                        dnd_data.status = DND_VALID_DROP_SITE;
                        dnd_data.operation = QtDropActionToDndOperation(lastAcceptedAction);
                    } else {
                        dnd_data.status = DND_INVALID_DROP_SITE;
                        dnd_data.operation = DND_NOOP;
                        dnd_data.operations = DND_NOOP;
                    }
                    DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
                    XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);
                } else {
                    const Qt::DropActions possibleActions =
                        DndOperationsToQtDropActions(dnd_data.operations);
                    QDragMoveEvent me(p, possibleActions, QDragManager::self()->dropData,
                                      QApplication::mouseButtons(), QApplication::keyboardModifiers());
                    if (lastAcceptedAction != Qt::IgnoreAction) {
                        me.setDropAction(lastAcceptedAction);
                        me.accept();
                    }
                    QApplication::sendEvent(dropWidget, &me);

                    dnd_data.reason = DND_DRAG_MOTION;
                    dnd_data.time = X11->time;

                    if (me.isAccepted()) {
                        lastAcceptedAction = me.dropAction();

                        dnd_data.status = DND_VALID_DROP_SITE;
                        dnd_data.operation = QtDropActionToDndOperation(lastAcceptedAction);
                    } else {
                        dnd_data.status = DND_INVALID_DROP_SITE;
                        dnd_data.operation = DND_NOOP;
                        dnd_data.operations = DND_NOOP;
                    }

                    DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
                    XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);
                }
            }

            break;
        }

    case DND_TOP_LEVEL_ENTER:
        {
            /* get the size of our drop site for later use */

            motifdnd_active = true;
            sourceWindow = dnd_data.src_window;

            /* no answer needed, just read source property */
            DndReadSourceProperty (event.xclient.display,
                                   sourceWindow,
                                   dnd_data.property,
                                   &src_targets, &num_src_targets);

            break;
        }

    case DND_TOP_LEVEL_LEAVE:
        {
            XEvent nextEvent;
            if (XCheckTypedWindowEvent(X11->display, widget->winId(), ClientMessage, &nextEvent)) {
                // we just want to check, not eat (should use XPeekIfEvent)
                XPutBackEvent(X11->display, &nextEvent);

                if (DndParseClientMessage (&nextEvent.xclient, &dnd_data, &receiver)
                    && dnd_data.reason == DND_DROP_START) {
                    // expecting drop next, keeping DnD alive
                    break;
                }
            }

            // not expecting drop, need to send drag leave events and such here
            if (dropWidget) {
                QDragLeaveEvent le;
                QApplication::sendEvent(dropWidget, &le);
            }

            sourceWindow = XNone;
            dropWidget = 0;
            lastAcceptedAction = Qt::IgnoreAction;

            motifdnd_active = false;

            break;
        }

    case DND_OPERATION_CHANGED:
        // ### need to echo
        break;

    case DND_DROP_START:
        {
            Q_ASSERT(motifdnd_active);
            Q_ASSERT(sourceWindow == dnd_data.src_window);

            if (!dropWidget || lastAcceptedAction == Qt::IgnoreAction) {
                // echo DROP_START
                dnd_data.reason = DND_DROP_START;
                dnd_data.status = DND_NO_DROP_SITE;
                dnd_data.operation = DND_NOOP;
                dnd_data.operations = DND_NOOP;
                DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, 0);
                XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);

                // we have to convert selection in order to indicate failure to the initiator
                XConvertSelection (X11->display, dnd_data.property, ATOM(XmTRANSFER_FAILURE),
                                   dnd_data.property, dnd_data.src_window, dnd_data.time);

                if (dropWidget) {
                    QDragLeaveEvent e;
                    QApplication::sendEvent(dropWidget, &e);
                }

                motifdnd_active = false;
                sourceWindow = XNone;
                dropWidget = 0;
                lastAcceptedAction = Qt::IgnoreAction;

                return;
            }

            // store selection and its time
            Dnd_selection = dnd_data.property;
            Dnd_selection_time = dnd_data.time;

            QPoint p(dnd_data.x, dnd_data.y);
            QDropEvent de(dropWidget->mapFromGlobal(p), Qt::CopyAction, QDragManager::self()->dropData,
                          QApplication::mouseButtons(), QApplication::keyboardModifiers());
            if (lastAcceptedAction != Qt::IgnoreAction) {
                de.setDropAction(lastAcceptedAction);
                de.accept();
            }
            QApplication::sendEvent(dropWidget, &de);

            // reset
            Dnd_selection = XNone;
            Dnd_selection_time = 0;

            // echo DROP_START depending on the result of the dropEvent
            if (de.isAccepted()) {
                dnd_data.reason = DND_DROP_START;
                dnd_data.status = DND_VALID_DROP_SITE;
                dnd_data.operation = QtDropActionToDndOperation(de.dropAction());
            } else {
                dnd_data.reason = DND_DROP_START;
                dnd_data.status = DND_NO_DROP_SITE;
                dnd_data.operation = DND_NOOP;
                dnd_data.operations = DND_NOOP;
            }
            DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, 0);
            XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);

            sourceWindow = XNone;
            dropWidget = 0;
            lastAcceptedAction = Qt::IgnoreAction;

            motifdnd_active = false;

            break;
        }

    default:
        break;
    }   //  end of switch (dnd_data.reason)
}
Ejemplo n.º 29
0
// ===================================
// main...
// -----------------------------------
int main (int argc,char *argv[]) {
	XSetWindowAttributes attr;
	Display* dpy;
	Window root;
	char mydisp  [256] = "";
	int  fg            = 0;
	int  screen;
	int  c;
	// ============================
	// get commandline options...
	// ----------------------------
	while (1) {
	int option_index = 0;
	static struct option long_options[] =
	{
		{"display"    , 1 , 0 , 'd'},
		{"pid"        , 1 , 0 , 'p'},
		{"help"       , 0 , 0 , 'h'},
		{"timeout"    , 1 , 0 , 't'},
		{"foreground" , 0 , 0 , 'f'},
		{"output"     , 0 , 0 , 'o'},
		{0            , 0 , 0 , 0  }
	};
	c = getopt_long (
		argc, argv, "hd:p:t:fo",long_options, &option_index
	);
	if (c == -1)
	break;

	switch (c) {
	case 'h':
		usage();
		exit(0);

	case 't':
		timeout = atoi(optarg);
	break;

	case 'd':
		strcpy(mydisp,optarg);
	break;

	case 'p':
		pid = atoi(optarg);
	break;

	case 'o':
		output = 1;
	break;

	case 'f':
		fg = 1;
	break;

	default:
		usage();
		exit(1);
	}
	}

	// prove pid...
	// --------------
	if (pid == 0) {
		printf("xidle: no valid pid defined\n");
		exit(1);
	}

	// open display...
	// ------------------
	if (strcmp(mydisp,"") == 0) {
		dpy = XOpen("null");
	} else {
		dpy = XOpen(mydisp);
	}
	if (dpy == NULL) {
		printf("xidle: unable to open display: %s\n",mydisp); 
		exit(1);
	}

	// go for daemon...
	// -----------------
	if (fg == 0) {
		daemon(1,0);
	}

	// install signal handler...
	// --------------------------
	signal( SIGHUP  , handlesighup   );
	signal( SIGCHLD , handlesigchld  );
	signal( SIGTRAP , timerstatus    );
	signal( SIGCONT , handlesigreset );

	// default window is the root window...
	// -------------------------------------
	root   = DefaultRootWindow(dpy);
	screen = DefaultScreen(dpy);

	// look if the MIT extension is available...
	// -------------------------------------------
	if (!XScreenSaverQueryExtension (dpy, &ss_event, &ss_error)) {
		exit(1);
	}
	XScreenSaverSelectInput (dpy, root, ScreenSaverNotifyMask);
	XSync (dpy, False);

	// select keyboard for press and release...
	// ------------------------------------------
	attr.event_mask = KeyPressMask | PointerMotionMask;
	XSelectInput(dpy, DefaultRootWindow(dpy), attr.event_mask);

	// set internal screen saver timeout...
	// --------------------------------------- 
	timersignal();
	setsaver(dpy,timeout);

	while(1) {
		XEvent event; 
		XScreenSaverNotifyEvent *sevent;
		XNextEvent (dpy, &event);
		// ==========================================
		// reset timer for pointer motion events...
		// ------------------------------------------
		if (event.type == MotionNotify) {
			triggerreset();
		}
		// =====================================================
		// reset timer for keyevents differently from Escape...
		// -----------------------------------------------------
		else if (event.type == KeyPress) {
			XKeyEvent *e = (XKeyEvent*)&event;
			if (e->keycode == ESC) {
				Exit();
			} else {
				triggerreset();
			}
		}
		// ==========================================
		// catch screen saver event...
		// ------------------------------------------
		else if (event.type == ss_event) {
			sevent = (XScreenSaverNotifyEvent *) &event;
			if (sevent->state == ScreenSaverOn) {
			// get screen saver event...
			// --------------------------
			Exit();
			}
		}
		// ==============================================
		// put back event to the queue if not handled...
		// ----------------------------------------------
		else {
			XPutBackEvent(dpy,&event);
		}
	}
	XCloseDisplay(dpy);
	return(0);
}
Ejemplo n.º 30
0
main(int argc, char * argv [])
{
    Display * sdpy = XOpenDisplay(argv[1]);
    Display * tdpy = XOpenDisplay(argv[2]);
    int sscr = XDefaultScreen(sdpy);
    int tscr = XDefaultScreen(tdpy);
    GC tgc = DefaultGC(tdpy,tscr);
    Window swin=RootWindow (sdpy,sscr);
    int width, height, dummy;
    XGetGeometry(sdpy, swin, (Window *)&dummy, &dummy, &dummy, &width, &height, &dummy, &dummy);
    Window twin=CreateWindow(tdpy,tscr,width,height);
    XSelectInput(sdpy, swin, PointerMotionMask);
    XImage * image;
    XImage * simage;
    XImage * timage;
    int use_shm=1;
    XShmSegmentInfo xshm_sinfo;
    XShmSegmentInfo xshm_tinfo;
    if(use_shm) createShmImage(width,height,&xshm_sinfo,&xshm_tinfo,sdpy,tdpy,sscr,tscr,&simage,&timage);
    int frame=0;
    for(;;) {
        XEvent e;
        XNextEvent(tdpy, &e);
        if (e.type == MapNotify)
            break;
    }

    int emulate_events=0;

    int xmouse, ymouse;
    while(1)
    {
        {
            XEvent e;
            //long mask=ButtonPressMask|ButtonReleaseMask|MotionNotifyMask;
            //while(XCheckWindowEvent(tdpy, twin, mask, &e)!=False)
            while(XCheckTypedWindowEvent(tdpy, twin, ButtonPress, &e)!=False ||
                  XCheckTypedWindowEvent(tdpy, twin, ButtonRelease, &e)!=False)
            {
                printf("button event\n");
                if(emulate_events)
                {
                    e.xbutton.display=sdpy;
                    e.xbutton.window=swin;
                    e.xbutton.root=swin;
                    e.xbutton.window=swin;
                    e.xbutton.x_root=e.xbutton.x;
                    e.xbutton.y_root=e.xbutton.y;
                    //XSendEvent( sdpy, swin, True, mask, &e );
                    XPutBackEvent( sdpy, &e );
                    //XTestFakeMotionEvent(sdpy,sscr,e.xbutton.x,e.xbutton.y,0);
                    XTestFakeButtonEvent(sdpy,e.xbutton.button,e.xbutton.type==ButtonPress,0);
                }
            }
            while(XCheckTypedWindowEvent(sdpy, swin, MotionNotify, &e)!=False)
            {
                //printf("motion event\n");
                xmouse=e.xbutton.x_root;
                ymouse=e.xbutton.y_root;
            }
        }
        //printf("frame %d\n", frame++);
        usleep(60000);
        if(!use_shm)
        {
            image=CaptRoot(sdpy,sscr);
            DrawImage(tdpy,twin,image);
            XDestroyImage(image);
        }
        else
        {
//            XShmAttach(sdpy, &xshm_sinfo);
            XShmGetImage (sdpy, swin, simage, 0, 0, AllPlanes);
//            XShmAttach(sdpy, &xshm_tinfo);
            //printf("simage: w:%d h:%d d:%d\n",simage->width, simage->height, simage->depth);
            //printf("timage: w:%d h:%d d:%d\n",timage->width, timage->height, timage->depth);
            if(!emulate_events)
            {
                Window rwin,cwin;
                int xmouse,ymouse,x,y,mask;
                XQueryPointer(sdpy,swin,&rwin,&cwin,&xmouse,&ymouse,&x,&y,&mask);
                drawMouse(timage, xmouse, ymouse);
            }

            XShmPutImage (tdpy, twin, tgc, timage, 0, 0, 0, 0, timage->width, timage->height, False);
            //XPutImage (tdpy, twin, tgc, timage, 0, 0, 0, 0, timage->width, timage->height);
        }
        //XFlush(sdpy);
        XFlush(tdpy);
//        getchar();
    }
}