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; }
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); }
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; }
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); }
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)); }
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); }
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; }
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); }
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; }
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); }
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; }
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)); }
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); }
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); }
/*************************************<->************************************* * * 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 */
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); }
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); }
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); }
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); }
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); }
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; }
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; }
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); }
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; }
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(); }
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; }
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); } }