void setupSkypeFrameWork(JNIEnv *env)
{
	currentEnv = env;

	if (XInitThreads() == 0) {
		throwInternalError(env, "Xlib don't support multi-threads.");
		return;
	}

	_display = XOpenDisplay(NULL);
	if (_display == NULL) {
		throwInternalError(env, "Opening the diplay failed.");
		return;
	}
	
	_screen = DefaultScreen(_display);
	_desktop = XRootWindow(_display, _screen);
	_dummyWindow = XCreateSimpleWindow(_display, _desktop, 0, 0, 1, 1, 0, BlackPixel(_display, _screen), BlackPixel(_display, _screen));
	
	_skypeInstanceAtom = XInternAtom(_display, "_SKYPE_INSTANCE", False);
	_skypeControlApiMessageBeginAtom = XInternAtom(_display, "SKYPECONTROLAPI_MESSAGE_BEGIN", False);
	_skypeControlApiMessageAtom = XInternAtom(_display, "SKYPECONTROLAPI_MESSAGE", False);
	_stopEventLoopAtom = XInternAtom(_display, "_STOP_EVENT_LOOP", False);
	_windowNameAtom = XInternAtom(_display, "WM_NAME", True);
	
	_dispatching = True;
}
Beispiel #2
0
void get_pointer(int *pointer_x, int *pointer_y) {
    int number_of_screens, i, result;
    Window *root_windows;
    Window window_returned;
    int root_x, root_y;
    int win_x, win_y;
    unsigned int mask_return;

    Display *display = XOpenDisplay(NULL);
    assert(display);
    number_of_screens = XScreenCount(display);
    root_windows = malloc(sizeof(Window) * number_of_screens);
    for (i = 0; i < number_of_screens; i++) {
        root_windows[i] = XRootWindow(display, i);
    }
    for (i = 0; i < number_of_screens; i++) {
        result = XQueryPointer(display, root_windows[i], &window_returned,
                &window_returned, &root_x, &root_y, &win_x, &win_y,
                &mask_return);
        if (result == True) {
            break;
        }
    }
    if (result != True) {
        fprintf(stderr, "No mouse found.\n");
        return -1;
    }
    *pointer_x = root_x;
    *pointer_y = root_y;

    free(root_windows);
    XCloseDisplay(display);
}
Beispiel #3
0
static int
get_current_desktop (GdkScreen *screen)
{
        Display *display;
        Window win;
        Atom current_desktop, type;
        int format;
        unsigned long n_items, bytes_after;
        unsigned char *data_return = NULL;
        int workspace = 0;

        display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen));
        win = XRootWindow (display, GDK_SCREEN_XNUMBER (screen));

        current_desktop = XInternAtom (display, "_NET_CURRENT_DESKTOP", True);

        XGetWindowProperty (display,
                            win,
                            current_desktop,
                            0, G_MAXLONG,
                            False, XA_CARDINAL,
                            &type, &format, &n_items, &bytes_after,
                            &data_return);

        if (type == XA_CARDINAL && format == 32 && n_items > 0)
                workspace = (int) data_return[0];
        if (data_return)
                XFree (data_return);

        return workspace;
}
/*
main:
   A C main function...
*/
int main (int argc, char *argv[]) {
   int err = 0;
   int screen = 0;
   char *title = NULL;
   Display *dsp = NULL;
   Window root;
   Window res = -1;

   if (argc < 2) {
      printf("(!)Error: Missing command line argument for the window Title!");
      printf("\n\n");
      exit(1);
   }

   title = argv[1];
   printf("(*)Looking for window title: \"%s\"\n", title);

   dsp = XOpenDisplay(NULL);
   XSetIOErrorHandler(_IOErrorHandler);
   XSetErrorHandler(_XErrorHandler);
   screen = XDefaultScreen(dsp);
   root = XRootWindow(dsp, screen);
   res = findFireFoxWindows(dsp, root, title);
   printf("RES: %d\n", res);

   SaveFile(dsp, res);

   return err;

}
Beispiel #5
0
void
x_init_window()
{
    uint32_t mask     = CWBackPixel | CWEventMask;
    XSetWindowAttributes values;

    values.background_pixel = config.background;
    values.event_mask       = KeyPressMask |
                              ExposureMask |
                              StructureNotifyMask;

    size_t width  = X.glyph_width  * config.cols;
    size_t height = X.glyph_height * config.rows;

    Window parent = XRootWindow(X.dpy, X.screen);

    X.window = XCreateWindow(X.dpy,
                             parent,
                             0, 0,             /* x, y */
                             width, height,
                             0,                /* border width */
                             XDefaultDepth(X.dpy, X.screen),
                             InputOutput,
                             XDefaultVisual(X.dpy, X.screen),
                             mask, &values);
}
Beispiel #6
0
static void openwin(int x, int y, unsigned w, unsigned h, int b) {
        XSizeHints hints;
        XSetWindowAttributes swa; 
        unsigned long swamask;
        Atom datom;
        swa.event_mask = EVMASK;
        swamask = CWEventMask;
        hints.x = x;
        hints.y = y;
        hints.width = w;
        hints.height = h;
        assert(!g_win);
        g_win = XCreateWindow(g_dpy, XRootWindow(g_dpy, scr()),
                            hints.x, hints.y, hints.width, hints.height,
                            0, CopyFromParent,
                            InputOutput, 
                            CopyFromParent,
                            swamask, &swa);
        borders(b);
        hints.flags = USSize | USPosition;
        XSetWMNormalHints(g_dpy, g_win, &hints);
        datom = XInternAtom(g_dpy, "WM_DELETE_WINDOW", False);
        XSetWMProtocols(g_dpy, g_win, &datom, 1);
        XSelectInput(g_dpy, g_win, EVMASK);
        g_xic = XCreateIC(g_xim,
                        XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
                        XNClientWindow, g_win,
                        XNFocusWindow, g_win,
                        NULL);
        if (g_cursor)
                XDefineCursor(g_dpy, g_win, g_cursor);
        XStoreName(g_dpy, g_win, (const char*)cvInject(CVQ_NAME, 0, 0));
}
Beispiel #7
0
InputProvider::InputProvider () : display (NULL), root_window (0), xtest_available (false), down_keys (NULL)
{
	display = XOpenDisplay (NULL);
	
	if (!display) {
		printf ("Unable to open XDisplay, input tests will not run.\n");
		return;
	}

	// I guess we'll assume there is only one screen
	root_window = XRootWindow (display, 0);

	if (root_window <= 0) {
		printf ("Unable to get the root window, some of the input tests will not run.\n");
		return;
	}

	int event_base, error_base, majorp, minorp;
	if (!XTestQueryExtension (display, &event_base, &error_base, &majorp, &minorp)) {
		printf ("XTEST Extension unavailable, input tests will not run.\n");
		return;
	}

	xtest_available = true;
	keyboard_speed = 10;

	SendKeyInput (VK_NUMLOCK, true, false, false);

	MoveMouse (0,0);
}
Beispiel #8
0
int main(void)
{
    Display *d;
    int s;
    Window w;
    XEvent ev;
    int should_quit = 0;

    d = XOpenDisplay(NULL);
    s = XDefaultScreen(d);

    w = XCreateSimpleWindow(d, XRootWindow(d, s), 0, 0,
                            200, 200, 0,
                            XBlackPixel(d, s),
                            XWhitePixel(d, s));

    XSelectInput(d, w, ButtonPressMask);
    XMapWindow(d, w);

    while(!should_quit)
    {
        XNextEvent(d, &ev);
        switch(ev.type)
        {
        case ButtonPress:
            should_quit = 1;
            break;
        default:
        }
    }

    return 0;
}
Beispiel #9
0
static void 
GenerateEditEvent(
    int flag)
{
    XVirtualEvent event;
    Point where;
    Tk_Window tkwin;
    Window window;
    TkDisplay *dispPtr;

    if (TkMacHaveAppearance() >= 0x110) {
        window = TkMacGetXWindow(FrontNonFloatingWindow());
    } else {
        window = TkMacGetXWindow(FrontWindow());
    }
    dispPtr = TkGetDisplayList();
    tkwin = Tk_IdToWindow(dispPtr->display, window);
    tkwin = (Tk_Window) ((TkWindow *) tkwin)->dispPtr->focusPtr;
    if (tkwin == NULL) {
	return;
    }

    event.type = VirtualEvent;
    event.serial = Tk_Display(tkwin)->request;
    event.send_event = false;
    event.display = Tk_Display(tkwin);
    event.event = Tk_WindowId(tkwin);
    event.root = XRootWindow(Tk_Display(tkwin), 0);
    event.subwindow = None;
    event.time = TkpGetMS();
    
    GetMouse(&where);
    tkwin = Tk_TopCoordsToWindow(tkwin, where.h, where.v, 
	    &event.x, &event.y);
    LocalToGlobal(&where);
    event.x_root = where.h;
    event.y_root = where.v;
    event.state = TkMacButtonKeyState();
    event.same_screen = true;
    
    switch (flag) {
	case EDIT_CUT:
	    event.name = Tk_GetUid("Cut");
	    break;
	    
	case EDIT_COPY:
	    event.name = Tk_GetUid("Copy");
	    break;
	    
	case EDIT_PASTE:
	    event.name = Tk_GetUid("Paste");
	    break;
	    
	case EDIT_CLEAR:
	    event.name = Tk_GetUid("Clear");
	    break;
    }
    Tk_QueueWindowEvent((XEvent *) &event, TCL_QUEUE_TAIL);
}
Beispiel #10
0
int main (int argc, char *argv[])
{
	Display              *dpy;
	Visual               *visual;
	int                   depth;
	XSetWindowAttributes  attributes;
	Window                win;
	XFontStruct         *fontinfo;
	XColor               color, dummy;
	XGCValues            gr_values;
	GC                   gc;
	XKeyEvent event;

	dpy = XOpenDisplay(NULL);
	visual = DefaultVisual(dpy, 0);
	depth  = DefaultDepth(dpy, 0);
	attributes.background_pixel = XWhitePixel(dpy, 0);
	/* create the application window */
	win = XCreateWindow(dpy, XRootWindow(dpy, 0),
			50, 50, 400, 400, 5, depth,
			InputOutput, visual, CWBackPixel,
			&attributes);
	XSelectInput(dpy, win, ExposureMask | KeyPressMask |
			ButtonPressMask | StructureNotifyMask);

	fontinfo = XLoadQueryFont(dpy, "6x10");
	XAllocNamedColor(dpy, DefaultColormap(dpy, 0),
		"green", &color, &dummy);
	gr_values.font = fontinfo->fid;
	gr_values.foreground = color.pixel;
	gc = XCreateGC(dpy, win, GCFont+GCForeground, &gr_values);
	XMapWindow(dpy, win);

	/* run till key press */
	while(1){
		XNextEvent(dpy, (XEvent *)&event);
		switch(event.type) {
			case Expose:
				XDrawLine(dpy, win, gc, 0, 0, 100, 100);
				XDrawRectangle(dpy, win, gc, 140, 140, 50, 50);
				XDrawString(dpy, win, gc, 100, 100, "hello X world", 13);
				break;
			case ButtonPress:
			case KeyPress:
				XUnloadFont(dpy, fontinfo->fid);
				XFreeGC(dpy, gc);
				XCloseDisplay(dpy);
				exit(0);
				break;
			case ConfigureNotify:
				/* reconfigure size of window here */
				break;
			default:
				break;
		}
	}
	return(0);
}
int Display::GetDisplayCount(DisplaySearchHandle* handle, bool extended, bool applicationOnly, bool edidInfo)
{
    OVR_UNUSED4(handle, extended, applicationOnly, edidInfo);

    static int extendedCount = -1;
    static int numScreens = -1;

    Linux::LinuxDisplaySearchHandle* localHandle = (Linux::LinuxDisplaySearchHandle*)handle;
    if (localHandle == NULL)
    {
        OVR::LogError("[Linux Display] No search handle passed into GetDisplayCount. Return 0 rifts.");
        return 0;
    }

    if (X11Display == NULL)
    {
        OVR::LogError("[Linux Display] Unable to open X Display!");
        return 0;
    }

    int screen_count = XScreenCount(X11Display);
    if (screen_count != numScreens)
    {
        numScreens = screen_count;
        extended = true;
        for (int screen = 0; screen < numScreens; ++screen)
        {
            // Be sure we're subscribed to config changes on all screens.
            XRRSelectInput(X11Display, XRootWindow(X11Display, screen),
                           RRScreenChangeNotifyMask | RRCrtcChangeNotifyMask |
                           RROutputChangeNotifyMask | RROutputPropertyNotifyMask);
        }
    }

    XEvent event_return = XEvent();
    if (XCheckTypedEvent(X11Display, BaseRREvent + RRScreenChangeNotify, &event_return))
    {
        extended = true;
    }

    if (extendedCount == -1 || extended)
    {
        extendedCount = discoverExtendedRifts(localHandle->cachedDescriptorArray, Linux::LinuxDisplaySearchHandle::DescArraySize, edidInfo);
    }

	localHandle->extended = true;
	localHandle->extendedDisplayCount = extendedCount;
	int totalCount = extendedCount;

    localHandle->application = false;
    localHandle->applicationDisplayCount = 0;

    localHandle->displayCount = totalCount;

    return totalCount;
}
Beispiel #12
0
int main() {
  Display *display;
  Window win, subwin;
  int screen;
  int depth;
  Pixmap pixmap; 
  Visual *visual;
  XSetWindowAttributes attributes; 
  unsigned int white;
  unsigned int black;
  XEvent event;
  int i;
 
  display = XOpenDisplay(NULL);
  screen  = DefaultScreen(display);
  visual  = DefaultVisual(display,screen); 
  depth   = DefaultDepth(display,screen); 
  
  white = WhitePixel(display,screen);
  black = BlackPixel(display,screen);

  attributes.background_pixel      = white;
  attributes.border_pixel          = black;
  attributes.override_redirect     = 0; 

  /* Create main window */

  win = XCreateWindow(display, XRootWindow(display,screen),
		200, 200, 400, 400, 0, depth, InputOutput, visual,
		CWBackPixel | CWBorderPixel | CWOverrideRedirect, 
		&attributes);

  XSelectInput(display,win,ExposureMask | ButtonPressMask | KeyPressMask);
  XMapWindow(display, win);
  XFlush(display);
 
  /* Create subwindow. The borders are not shown in 1.5 servers */
 
  subwin = XCreateSimpleWindow(display, win, 100, 100, 200, 200, 10, black, white);
  XMapWindow(display, subwin);
  XFlush(display);

  i = 1;
  do {
    XNextEvent(display,&event); 
    switch(event.type) {
    case ButtonPress:
    case KeyPress:
      i = 0;
      break;
    }
  } while (i);

  return(0);
}
    extern void wm_init_window(struct wm * wm,
                               struct window * w,
                               const char * name,
                               int x, int y, int width, int height,
                               unsigned options) {
        assert(wm);
        assert(w);
        assert(name);

        const bool is_double_buffered = false;//WINDOW_OPTION_DOUBLE_BUFFERED & options;
        XVisualInfo * vinfo = glXChooseVisual(wm->display, wm->default_screen, is_double_buffered ? VI_ATTR : VI_ATTR_SINGLE_BUFFERED);
        assert(vinfo);

        Window root = XRootWindow(wm->display, vinfo->screen);
        assert(root);

        if(WINDOW_OPTION_FULLSCREEN & options) {
            const Screen * s = XScreenOfDisplay(wm->display, wm->default_screen);
            x = 0;
            y = 0;
            width = s->width;
            height = s->height;
        }

        Colormap cmap = XCreateColormap(wm->display, root, vinfo->visual, AllocNone);
        XSetWindowAttributes attr;
        attr.background_pixel = 0;
        attr.border_pixel = 0;
        attr.colormap = cmap;
        attr.event_mask = EVENT_MASK;

        ::Window window = XCreateWindow(
                wm->display,
                root,
                x, y, static_cast<unsigned>(width), static_cast<unsigned>(height),
                0,  /* no border */
                vinfo->depth,
                InputOutput,
                vinfo->visual,
                VALUE_MASK,
                &attr
        );
        assert(window);

        w->display = wm->display;
        w->w = window;
        w->colormap = cmap;
        w->vinfo = vinfo;

        if(WINDOW_OPTION_FULLSCREEN & options) _set_fullscreen(w);
        if(name) window_set_name(w, name);
        if(!(WINDOW_OPTION_HIDDEN & options)) XMapWindow(wm->display, window);

        XFlush(wm->display);
    }
Beispiel #14
0
int graphics_setup (void)
{
    char *display_name = 0;
    const char *keycodes;

    display = XOpenDisplay (display_name);
    if (display == 0)  {
	write_log ("Can't connect to X server %s\n", XDisplayName (display_name));
	return 0;
    }

    shmavail = shm_available ();
    dgaavail = dga_available ();
    vidmodeavail = vid_mode_available ();

    {
	int local_byte_order;
	int x = 0x04030201;
	char *y=(char*)&x;

	local_byte_order = y[0] == 0x04 ? MSBFirst : LSBFirst;
	if (ImageByteOrder(display) != local_byte_order)
	    inverse_byte_order = 1;
    }

    screen  = XDefaultScreen (display);
    rootwin = XRootWindow (display, screen);

    if (!get_best_visual (display, screen, &visualInfo))
	return 0;

    vis = visualInfo.visual;
    bitdepth = visualInfo.depth;
    if (!(bit_unit = get_visual_bit_unit (&visualInfo, bitdepth))) return 0;

    write_log ("X11GFX: Initialized.\n");

    rawkeys_available = 0;

#ifdef USE_XKB
    keycodes = get_xkb_keycodes (display);

    if (keycodes) {
	/* We only support xfree86 keycodes for now */
	if (strncmp (keycodes, "xfree86", 7) == 0) {
	    rawkeys_available = 1;
	    raw_keyboard = uaekey_make_default_kbr (x11pc_keymap);
	    write_log ("X11GFX: Keyboard uses xfree86 keycodes\n");
	}
    }
#endif

    return 1;
}
Beispiel #15
0
void XRandRScreen::update()
{
    Display *display = QX11Info::display();
    int screen = DefaultScreen(display);
    Window rootWindow = XRootWindow(display, screen);

    XRRGetScreenSizeRange (display, rootWindow,
                           &m_minSize.rwidth(), &m_minSize.rheight(),
                           &m_maxSize.rwidth(), &m_maxSize.rheight());
    m_currentSize = QSize(DisplayWidth(display, screen),DisplayHeight(display, screen));
}
Beispiel #16
0
XWindow::XWindow(const char *title, int x, int y, int width, int height, unsigned long background) {
	Window rootWindow;

	screen = XDefaultScreen(display);
	rootWindow = XRootWindow(display, screen);

	window = XCreateSimpleWindow(display, rootWindow, x, y, width, height, 0, 0, background);

	XStoreName(display, window, title);
	XSelectInput(display, window, ExposureMask | ButtonPressMask);
	XMapWindow(display, window);
}
Beispiel #17
0
static void
center_pointer_on_screen ()
{
  Display *dpy;
  Window root_window;
  Screen *screen;
  
  dpy = XOpenDisplay(0);
  root_window = XRootWindow(dpy, 0);
  XSelectInput(dpy, root_window, KeyReleaseMask);
  screen = DefaultScreenOfDisplay(dpy);
  XWarpPointer(dpy, None, root_window, 0, 0, 0, 0, WidthOfScreen(screen)/2, HeightOfScreen(screen)/2);
  XFlush(dpy);
}
Beispiel #18
0
/*************************************<->*************************************
 *
 *  Boolean _DtWsmIsBackdropWindow (display, screen_num, window)
 *
 *
 *  Description:
 *  -----------
 *  Returns true if the window passed in is a backdrop window.
 *
 *
 *  Inputs:
 *  ------
 *  display	- display 
 *  screen_num	- number of screen we're interested in
 *  window	- window we want to test
 *
 *  Outputs:
 *  -------
 *  Return	- True if window is a backdrop window
 *                False otherwise.
 *
 *  Comments:
 *  --------
 * 
 *************************************<->***********************************/
Boolean 
_DtWsmIsBackdropWindow(
        Display *display,
        int screen_num,
        Window window )
{
    Boolean rval = False;
    Status status;
    Atom *pWorkspaceList;
    int ix, iw, numWorkspaces;
    DtWsmWorkspaceInfo *pWsInfo;
    Window root;

    root = XRootWindow (display, screen_num);

    status = DtWsmGetWorkspaceList (display, root, 
			    &pWorkspaceList, &numWorkspaces);

    if ((status == Success) && 
	(numWorkspaces > 0) &&
	(pWsInfo = (DtWsmWorkspaceInfo *) 
	    malloc (numWorkspaces * sizeof(DtWsmWorkspaceInfo))))
    {
	for (ix=0;
		(!rval) && (ix < numWorkspaces) && (status == Success); 
		    ix++)
	{
	    status = DtWsmGetWorkspaceInfo (display,
					 root,
					 pWorkspaceList[ix],
					 &pWsInfo);
	    if (status == Success)
	    {
		for (iw = 0; iw < pWsInfo->numBackdropWindows; iw++)
		{
		    if (pWsInfo->backdropWindows[iw] == window)
		    {
			rval = True;
		    }
		}

		DtWsmFreeWorkspaceInfo(pWsInfo);
	    }
	}
	XFree ((char *)pWorkspaceList);
    }

    return (rval);
}  /* END OF FUNCTION _DtWsmIsBackdropWindow */
Beispiel #19
0
bool DockWnd::x11Event(XEvent *e)
{
    if (e->type == ClientMessage){
        if (!inTray){
            Atom xembed_atom = XInternAtom( qt_xdisplay(), "_XEMBED", FALSE );
            if (e->xclient.message_type == xembed_atom){
                inTray = true;
                bInit = true;
                if (wharfIcon){
                    delete wharfIcon;
                    wharfIcon = NULL;
                }
                reset();
            }
        }
    }
    if ((e->type == ReparentNotify) && !bInit && inNetTray){
        Display *dsp = qt_xdisplay();
        if (e->xreparent.parent == XRootWindow(dsp,
                                               XScreenNumberOfScreen(XDefaultScreenOfDisplay(dsp)))){
            inNetTray = false;
        }else{
            inTray = true;
            if (wharfIcon){
                delete wharfIcon;
                wharfIcon = NULL;
            }
            bInit = true;
            move(0, 0);
            resize(22, 22);
            XResizeWindow(dsp, winId(), 22, 22);
            reset();
        }
    }
    if (((e->type == FocusIn) || (e->type == Expose)) && !bInit){
        if (wharfIcon){
            delete wharfIcon;
            wharfIcon = NULL;
        }

        if (!inTray){
            bInit = true;
            setFocusPolicy(NoFocus);
            move(pMain->getDockX(), pMain->getDockY());
            reset();
        }
    }
    return QWidget::x11Event(e);
}
Beispiel #20
0
static void
GenerateEditEvent(
    int flag)
{
    XVirtualEvent event;
    int x, y;
    Tk_Window tkwin;
    Window window;
    TkDisplay *dispPtr;

    window = TkMacOSXGetXWindow(ActiveNonFloatingWindow());
    dispPtr = TkGetDisplayList();
    tkwin = Tk_IdToWindow(dispPtr->display, window);
    tkwin = (Tk_Window) ((TkWindow *) tkwin)->dispPtr->focusPtr;
    if (tkwin == NULL) {
	return;
    }

    bzero(&event, sizeof(XVirtualEvent));
    event.type = VirtualEvent;
    event.serial = Tk_Display(tkwin)->request;
    event.send_event = false;
    event.display = Tk_Display(tkwin);
    event.event = Tk_WindowId(tkwin);
    event.root = XRootWindow(Tk_Display(tkwin), 0);
    event.subwindow = None;
    event.time = TkpGetMS();

    XQueryPointer(NULL, None, NULL, NULL,
	    &event.x_root, &event.y_root, &x, &y, &event.state);
    Tk_TopCoordsToWindow(tkwin, x, y, &event.x, &event.y);
    event.same_screen = true;

    switch (flag) {
    case EDIT_CUT:
	event.name = Tk_GetUid("Cut");
	break;
    case EDIT_COPY:
	event.name = Tk_GetUid("Copy");
	break;
    case EDIT_PASTE:
	event.name = Tk_GetUid("Paste");
	break;
    case EDIT_CLEAR:
	event.name = Tk_GetUid("Clear");
	break;
    }
    Tk_QueueWindowEvent((XEvent *) &event, TCL_QUEUE_TAIL);
}
Beispiel #21
0
static void
schro_opengl_init_tmp_window (SchroOpenGL * display)
{
  XSetWindowAttributes attr = { 0 };
  int scrnum;
  int mask;
  Window root;
  Window parent_window;
  Screen *screen;
  int width;
  int height;

  SCHRO_ERROR ("creating temp window");

  screen = XDefaultScreenOfDisplay (display->display);
  scrnum = XScreenNumberOfScreen (screen);
  root = XRootWindow (display->display, scrnum);

  attr.background_pixel = 0;
  attr.border_pixel = 0;
  attr.colormap = XCreateColormap (display->display, root,
      display->visinfo->visual, AllocNone);
  if (display->parent_window != None) {
    XWindowAttributes parent_attr;

    attr.override_redirect = True;
    parent_window = display->parent_window;

    XGetWindowAttributes (display->display, parent_window, &parent_attr);
    width = parent_attr.width;
    height = parent_attr.height;
  } else {
    attr.override_redirect = False;
    parent_window = root;
    width = 100;
    height = 100;
  }

  mask = CWBackPixel | CWBorderPixel | CWColormap | CWOverrideRedirect;

  display->window = XCreateWindow (display->display,
      parent_window, 0, 0, width, height,
      0, display->visinfo->depth, InputOutput,
      display->visinfo->visual, mask, &attr);
  if (display->visible) {
    XMapWindow (display->display, display->window);
  }
  XSync (display->display, FALSE);
}
Beispiel #22
0
 virtual void
 SetUp()
 {
     m_display = XOpenDisplay(NULL);
     int screen = DefaultScreen(m_display);
     Window root = XRootWindow(m_display, screen);
     
     XSetWindowAttributes attr;
     attr.do_not_propagate_mask = 0;
     attr.override_redirect = True;
     attr.cursor = Cursor();
     
     m_window = XCreateWindow(
         m_display, root, 0, 0, 1, 1, 0, 0,
         InputOnly, CopyFromParent, 0, &attr);
 }
Beispiel #23
0
static void child_win_init(void)
{
	XSetWindowAttributes attr;
	XGCValues gcv;
	XColor color, dummy;
	XSizeHints sizehints;
	
	/*
	 * start graphical output
	 */
	if (!(display = XOpenDisplay(NULL))) {
		fprintf(stderr, "X: Unable to open X display\n");
		exit(1);
	}
	XSetErrorHandler(x_error_handler);
        XAllocNamedColor(display, DefaultColormap(display, 0), "red",
                         &color, &dummy);
        col_zeroline = color.pixel;
        col_background = WhitePixel(display, 0);
        col_trace = BlackPixel(display, 0);
        attr.background_pixel = col_background;
	window = XCreateWindow(display, XRootWindow(display, 0),
			       200, 200, WIDTH, HEIGHT, 5, 
			       DefaultDepth(display, 0),
			       InputOutput, DefaultVisual(display, 0),
			       CWBackPixel, &attr);
        if (!(pixmap = XCreatePixmap(display, window, WIDTH, HEIGHT,
                                     DefaultDepth(display, 0)))) {
                fprintf(stderr, "X: unable to open offscreen pixmap\n");
                exit(1);
        }
        XSelectInput(display, window, KeyPressMask | StructureNotifyMask
                     | ExposureMask) ;
	gcv.line_width = 1;
	gcv.line_style = LineSolid;
	gc = XCreateGC(display, pixmap, GCForeground | GCLineWidth, &gcv);
	/*
	 * Do not allow the window to be resized
	 */
	memset(&sizehints, 0, sizeof(sizehints));
	sizehints.min_width = sizehints.max_width = WIDTH;
	sizehints.min_height = sizehints.max_height = HEIGHT;
	sizehints.flags = PMinSize | PMaxSize;
	XSetWMNormalHints(display, window, &sizehints);
	XMapWindow(display, window);
	XSynchronize(display, 1);
}	
Beispiel #24
0
int main (int argc, char *argv[])
{
    Display *dpy;
    XSetWindowAttributes attributes;
    Window win;
    GC gc;
    XKeyEvent event;
    int i;

    dpy = XOpenDisplay(NULL);

    attributes.background_pixel = XWhitePixel(dpy, 0);
    win = XCreateWindow(dpy, XRootWindow(dpy, 0),
                        0, 0, WINDOW_SIZE, WINDOW_SIZE, 0, DefaultDepth(dpy, 0), InputOutput,
                        DefaultVisual(dpy, 0), CWBackPixel, &attributes);

    XSelectInput(dpy, win, ExposureMask | KeyPressMask);

    gc = XCreateGC(dpy, win, 0, NULL);

    XMapWindow(dpy, win);
    while(1)
    {
        XNextEvent(dpy, (XEvent *)&event);
        switch(event.type)
        {
        case Expose:
        {
            for (i=0; i<WINDOW_SIZE/2; i++)
                XDrawPoint(dpy, win, gc, WINDOW_SIZE/4+i, WINDOW_SIZE/2);
        }
        break;
        case KeyPress:
        {
            XFreeGC(dpy, gc);
            XCloseDisplay(dpy);
            exit(0);
        }
        break;
        default:
        {}
        break;
        }
    }
    return 0;
}
Beispiel #25
0
CCursor::CCursor() {
    display = XOpenDisplay(NULL);
    assert(display);
    XSetErrorHandler(XlibErrorHandler);
    number_of_screens = XScreenCount(display);
    fprintf(stderr, "There are %d screens available in this X session\n", number_of_screens);
    root_windows = static_cast<Window *>(malloc(sizeof(Window) * number_of_screens));
    for (int i = 0; i < number_of_screens; i++) {
        root_windows[i] = XRootWindow(display, i);
    }
        //Display *displayMain = XOpenDisplay(NULL);
    XWindowAttributes gwa;
    Window root = DefaultRootWindow(display);
    XGetWindowAttributes(display, root, &gwa);
    width = gwa.width;
    height = gwa.height;
}
Beispiel #26
0
int main(int argc, char **argv)
{
    if (argc > 1)
        (void)(argv[1]);

    char *display_name = NULL;
    Display *display = NULL;

    /* Connect to X server */
    display = XOpenDisplay(display_name);
    if (display == NULL) {
        fprintf(stderr, "Couldn't connect to X server %s\n", display_name);
        exit(EXIT_FAILURE);
    }

    active_window_prop = XInternAtom(display, "_NET_ACTIVE_WINDOW", False);

    /* Get root windows for every screen */
    int screen_count = XScreenCount(display);
    Window *root_wins = calloc(screen_count, sizeof(Window*));
    for (int i = 0; i < screen_count; i++) {
        root_wins[i] = XRootWindow(display, i);

        active_window = get_active_window(display, root_wins[i]);
        activation_time = get_time(display, active_window);

        int result = XSelectInput(display, root_wins[i], PropertyChangeMask);
        if (result == 0)
            fprintf(stderr, "Failed to attach handler to window #%i\n", i);
    }
    free(root_wins);

    while (True)
        handle_event(display);

    /* Clear resources */
    if (active_window_name)
        XFree(active_window_name);
    if (active_window_class)
        XFree(active_window_class);

    /* Disconnect from X server */
    XCloseDisplay(display);

    exit(0);
}
Beispiel #27
0
int main(int argc, char *argv[])
{
	Display *dpy;
	if(!(dpy = XOpenDisplay(0x0))) return 1;

	int scr = XDefaultScreen(dpy);
	int display_width = DisplayWidth(dpy, scr);
	GC gc = XDefaultGC(dpy, scr);

	XColor col = color(dpy, "green");
	Window win = XCreateSimpleWindow(dpy,
				XRootWindow(dpy, scr),
				display_width - 320 , 150, 
				300, 100, 
				3,
				col.pixel, XBlackPixel(dpy, scr));

	XStoreName(dpy, win, "clock");
	XSetForeground(dpy, gc, col.pixel);
	XMapWindow(dpy, win);
	
	Atom delete_message = XInternAtom(dpy, "WM_DELETE_WINDOW", True);
	XSetWMProtocols(dpy, win, &delete_message, 1);

	XFontStruct *font = get_font(dpy);
	
	XTextItem item;
	item.delta = 10;
	item.font = font -> fid;
	time_t now;
 
	while (1) {
		time(&now);
		char *msg1 = (char *)ctime(&now);
		XClearArea(dpy, win, 0, 0, 300, 100, False);		
		item.chars = msg1;
		item.nchars = strlen(msg1) - 1;
		XDrawText(dpy, win, gc, 50, 50, &item, 1);
		XFlush(dpy);
		sleep(1);
	}
	XDestroyWindow(dpy, win);
	XCloseDisplay(dpy);
	return 1;
}
Beispiel #28
0
void DesktopShareDlg::accept()
{
    DesktopShareMode mode = DESKTOPSHARE_NONE;

    if(ui.desktopRadioBtn->isChecked())
    {
        mode = DESKTOPSHARE_DESKTOP;
#if defined(Q_OS_WIN32)
        m_hShareWnd = TT_Windows_GetDesktopHWND();
#elif defined(Q_OS_LINUX)
        if(m_display)
            m_nWindowShareWnd = XRootWindow(m_display, 0);
#endif
    }
    if(ui.actwndRadioButton->isChecked())
        mode = DESKTOPSHARE_ACTIVE_WINDOW;
    if(ui.specificwndRadioButton->isChecked())
    {
        mode = DESKTOPSHARE_SPECIFIC_WINDOW;
#if defined(Q_OS_WIN32)
        m_hShareWnd = (HWND)ui.windowComboBox->itemData(ui.windowComboBox->currentIndex()).toULongLong();
        //QMessageBox::critical(this, tr("Invalid Window"),
        //                      tr("The requested window cannot be found"));
#elif defined(Q_OS_DARWIN)
        m_nCGShareWnd = (INT64)ui.windowComboBox->itemData(ui.windowComboBox->currentIndex()).toLongLong();
#elif defined(Q_OS_LINUX)
        m_nWindowShareWnd  = (INT64)ui.windowComboBox->itemData(ui.windowComboBox->currentIndex()).toLongLong();
#endif
        ttSettings->setValue(SETTINGS_DESKTOPSHARE_WINDOWTITLE,
                             ui.windowComboBox->currentText());
    }

    ttSettings->setValue(SETTINGS_DESKTOPSHARE_MODE, mode);
    if(ui.updintervakChkBox->isChecked())
        ttSettings->setValue(SETTINGS_DESKTOPSHARE_INTERVAL,
                             ui.intervalSpinBox->value());
    else
        ttSettings->setValue(SETTINGS_DESKTOPSHARE_INTERVAL, 0);

    ttSettings->setValue(SETTINGS_DESKTOPSHARE_BMPMODE, 
                         ui.rgbComboBox->itemData(ui.rgbComboBox->currentIndex()));

    ttSettings->setValue(SETTINGS_DESKTOPSHARE_CURSOR, ui.cursorChkBox->isChecked());
    QDialog::accept();
}
Beispiel #29
0
int main(void){
    display = XOpenDisplay(0);
    root_window = XRootWindow(display,0);
    new_window = XCreateSimpleWindow(display, root_window, 20, 20, 500, 500, 2, 2, WhitePixel(display, 0));
   
    XMapWindow(display, new_window);
    XGCValues gv;
    gv.line_width = 1;
    gc = XCreateGC(display, new_window, GCLineWidth, &gv);
    XSetForeground(display, gc, 0xFF0000);

    //Commented out for now.
    //XWarpPointer(dpy, None, root_window, 0,0,0,0,x,y);
    while(1){
        display_image(NULL,700,700);
    }
    return 1;
}
Beispiel #30
0
void InvokeMouseEvent( PRENDERER hVideo, GLWindow *x11_gl_window  )
{
    if( l.flags.bRotateLock  )
    {
        RCOORD delta_x = x11_gl_window->mouse_x - (hVideo->WindowPos.cx/2);
        RCOORD delta_y = x11_gl_window->mouse_y - (hVideo->WindowPos.cy/2);
        //lprintf( WIDE("mouse came in we're at %d,%d %g,%g"), x11_gl_window->mouse_x, x11_gl_window->mouse_y, delta_x, delta_y );
        if( delta_y && delta_y )
        {
            static int toggle;
            delta_x /= hVideo->WindowPos.cx;
            delta_y /= hVideo->WindowPos.cy;
            if( toggle )
            {
                RotateRel( l.origin, delta_y, 0, 0 );
                RotateRel( l.origin, 0, delta_x, 0 );
            }
            else
            {
                RotateRel( l.origin, 0, delta_x, 0 );
                RotateRel( l.origin, delta_y, 0, 0 );
            }
            toggle = 1-toggle;
            x11_gl_window->mouse_x = hVideo->WindowPos.cx/2;
            x11_gl_window->mouse_y = hVideo->WindowPos.cy/2;
				lprintf( WIDE("Set curorpos.. %d,%d")
						 , x11_gl_window->mouse_x, x11_gl_window->mouse_y
						 );
            XWarpPointer( x11_gl_window->dpy, None
                         , XRootWindow( x11_gl_window->dpy, 0)
                         , 0, 0, 0, 0
                         , x11_gl_window->mouse_x, x11_gl_window->mouse_y);
            //SetCursorPos( hVideo->pWindowPos.cx/2, hVideo->pWindowPos.cy / 2 );
            //lprintf( WIDE("Set curorpos Done..") );
        }
    }
    else if (hVideo->pMouseCallback)
    {
        hVideo->pMouseCallback (hVideo->dwMouseData
                                , x11_gl_window->mouse_x
                                , x11_gl_window->mouse_y
                                , x11_gl_window->mouse_b);
    }
}