自学教程：C++ ConnectionNumber函数代码示例

voidR_gtk_setEventHandler(){#ifndef WIN32  static InputHandler *h = NULL;  if(!h)    {      if (!GDK_DISPLAY())        error("GDK display not found - please make sure X11 is running");      h = addInputHandler(R_InputHandlers, ConnectionNumber(GDK_DISPLAY()),                          R_gtk_eventHandler, -1);    }#else  /* Create a dummy window for receiving messages */  LPCTSTR class = "cairoDevice";  HINSTANCE instance = GetModuleHandle(NULL);  WNDCLASS wndclass = { 0, DefWindowProc, 0, 0, instance, NULL, 0, 0, NULL,                        class };  RegisterClass(&wndclass);  HWND win = CreateWindow(class, NULL, 0, 1, 1, 1, 1, HWND_MESSAGE,                          NULL, instance, NULL);  SetTimer(win, CD_TIMER_ID, CD_TIMER_DELAY, (TIMERPROC)R_gtk_timer_proc);#endif}

/** * XPending() actually performs a blocking read  *  if no events available. From Fakk2, by way of *  Heretic2, by way of SDL, original idea GGI project. * The benefit of this approach over the quite *  badly behaved XAutoRepeatOn/Off is that you get *  focus handling for free, which is a major win *  with debug and windowed mode. It rests on the *  assumption that the X server will use the *  same timestamp on press/release event pairs  *  for key repeats.  */static qboolean X11_PendingInput(void) {  assert(dpy != NULL);  // Flush the display connection  //  and look to see if events are queued  XFlush( dpy );  if ( XEventsQueued( dpy, QueuedAlready) ) {    return qtrue;  }  // More drastic measures are required -- see if X is ready to talk  {    static struct timeval zero_time;    int x11_fd;    fd_set fdset;    x11_fd = ConnectionNumber( dpy );    FD_ZERO(&fdset);    FD_SET(x11_fd, &fdset);    if ( select(x11_fd+1, &fdset, NULL, NULL, &zero_time) == 1 ) {      return(XPending(dpy));    }  }    // Oh well, nothing is ready ..  return qfalse;}

GSource *_clutter_x11_event_source_new (ClutterBackendX11 *backend_x11){  ClutterEventSource *event_source;  int connection_number;  GSource *source;  gchar *name;  connection_number = ConnectionNumber (backend_x11->xdpy);  CLUTTER_NOTE (EVENT, "Connection number: %d", connection_number);  source = g_source_new (&event_funcs, sizeof (ClutterEventSource));  event_source = (ClutterEventSource *) source;  name = g_strdup_printf ("Clutter X11 Event (connection: %d)",                          connection_number);  g_source_set_name (source, name);  g_free (name);  event_source->backend = backend_x11;  event_source->event_poll_fd.fd = connection_number;  event_source->event_poll_fd.events = G_IO_IN;  g_source_add_poll (source, &event_source->event_poll_fd);  g_source_set_can_recurse (source, TRUE);  return source;}

int main(int argc, char **argv){  if(argc == 2)    text = argv[1];  else {    printf("give an argument./n");    exit(1);  }  LOG_MESSAGE("starting xnotify/n");  initX();  signal(SIGHUP, sighup_handler);  signal(SIGINT, sigint_handler);    display_window();  init_and_start_ev_loop(ConnectionNumber(X.display));  cleanup();  return 0;}

static int spnav_fd(void){    if(dpy) {        return ConnectionNumber(dpy);    }    return -1;}

// Ping X in @pingInterval miliseconds.XServerPinger::XServerPinger(int pingInterval){    Display *dpy;    sigset_t sigs;    // Open a separate connection to X.    dpy = XOpenDisplay(NULL);    xcb = XGetXCBConnection(dpy);    connect(new QSocketNotifier(ConnectionNumber(dpy), QSocketNotifier::Read),            SIGNAL(activated(int)), SLOT(xInput(int)));    // XGetInputFocus() is our ping request.    request = xcb_get_input_focus(xcb);    xcb_flush(xcb);    timer = new QTimer();    connect(timer, SIGNAL(timeout()), SLOT(tick()));    timer->start(pingInterval);    // die() if we get SIGINT or SIGTERM.    sigemptyset(&sigs);    sigaddset(&sigs, SIGINT);    sigaddset(&sigs, SIGTERM);    connect(new QSocketNotifier(signalfd(-1, &sigs, 0),                                QSocketNotifier::Read),            SIGNAL(activated(int)), SLOT(die(int)));    sigprocmask(SIG_BLOCK, &sigs, NULL);}

/** Execute an external program. */void RunCommand(const char *command) {   const char *displayString;   char *str;   if(JUNLIKELY(!command)) {      return;   }   displayString = DisplayString(display);   if(!fork()) {      close(ConnectionNumber(display));      if(displayString && displayString[0]) {         str = malloc(strlen(displayString) + 9);         sprintf(str, "DISPLAY=%s", displayString);         putenv(str);      }      setsid();      execl(SHELL_NAME, SHELL_NAME, "-c", command, NULL);      Warning(_("exec failed: (%s) %s"), SHELL_NAME, command);      exit(EXIT_SUCCESS);   }}

int glwtEventHandle(int wait){    int handled = 0;    do    {        XFlush(glwt.x11.display);        handled = xlib_handle_event();        if(handled < 0)            return -1;        if(wait && handled == 0)        {            int fd;            fd_set fds;            fd = ConnectionNumber(glwt.x11.display);            FD_ZERO(&fds);            FD_SET(fd, &fds);            int val = select(fd + 1, &fds, NULL, NULL, NULL);            if(val == -1)            {                glwtErrorPrintf("select failed: %s", strerror(errno));                return -1;            } else if(val == 0)                return 0;        }    } while(handled == 0 && wait);    return 0;}

FtkSource* ftk_source_x11_create(FtkDisplay* display, FtkOnEvent on_event, void* ctx){	FtkSource* thiz = NULL;		return_val_if_fail(display != NULL && on_event != NULL, NULL);	thiz = (FtkSource*)FTK_ZALLOC(sizeof(FtkSource) + sizeof(PrivInfo));	if(thiz != NULL)	{		DECL_PRIV(thiz, priv);		thiz->get_fd   = ftk_source_x11_get_fd;		thiz->check	   = ftk_source_x11_check;		thiz->dispatch = ftk_source_x11_dispatch;		thiz->destroy  = ftk_source_x11_destroy;		thiz->ref = 1;		priv->ctx = ctx;		priv->on_event = on_event;		priv->display = display;		priv->fd  = ConnectionNumber(ftk_display_x11_get_xdisplay(display));		priv->win = (Window)ftk_display_x11_get_xwindow(display);		XSetErrorHandler(on_x11_error);	}	return thiz;}

static void getEvent(XEvent * ev) {    int fd;    fd_set readfds;    struct timeval tv;        /* Is there a message waiting? */    if (QLength(dpy) > 0) {        XNextEvent(dpy, ev);        return;    }        /* Beg... */    XFlush(dpy);        /* Wait one second to see if a message arrives. */    fd = ConnectionNumber(dpy);    FD_ZERO(&readfds);    FD_SET(fd, &readfds);    tv.tv_sec = 1;    tv.tv_usec = 0;    if (select(fd + 1, &readfds, 0, 0, &tv) == 1) {        XNextEvent(dpy, ev);        return;    }        /* No message, so we have a null event. */    ev->type = NullEvent;}

int main(){        Display *display_name;        int depth,screen,connection;        /*Opening display and setting defaults*/        display_name = XOpenDisplay(NULL);        screen = DefaultScreen(display_name);        depth = DefaultDepth(display_name,screen);        connection = ConnectionNumber(display_name);        /*Displaying the info gathered*/        printf("The display is::%s/n",XDisplayName((char*)display_name));        printf("Width::%d/tHeight::%d/n",                                DisplayWidth(display_name,screen),                                DisplayHeight(display_name,screen));        printf("Connection number is %d/n",connection);        if(depth == 1)                printf("You live in prehistoric times/n");        else                printf("You've got a coloured monitor with depth of %d/n",                        depth);        /*Closing the display*/        XCloseDisplay(display_name);}

gboolean_cogl_xlib_renderer_connect (CoglRenderer *renderer, GError **error){  CoglXlibRenderer *xlib_renderer =    _cogl_xlib_renderer_get_data (renderer);  CoglX11Renderer *x11_renderer =    (CoglX11Renderer *) xlib_renderer;  int damage_error;  if (!assert_xlib_display (renderer, error))    return FALSE;  if (getenv ("COGL_X11_SYNC"))    XSynchronize (xlib_renderer->xdpy, TRUE);  /* Check whether damage events are supported on this display */  if (!XDamageQueryExtension (xlib_renderer->xdpy,                              &x11_renderer->damage_base,                              &damage_error))    x11_renderer->damage_base = -1;  xlib_renderer->trap_state = NULL;  xlib_renderer->poll_fd.fd = ConnectionNumber (xlib_renderer->xdpy);  xlib_renderer->poll_fd.events = COGL_POLL_FD_EVENT_IN;  register_xlib_renderer (renderer);  return TRUE;}

/*ARGSUSED*/extern voidshell(ScreenInfo * screen, int button, int x, int y) {    char * command = NULL;    char * sh;    /* Get the command we're to execute. Give up if there isn't one. */    if (button == Button1)        command = btn1_command;    if (button == Button2)        command = btn2_command;    if (command == NULL)        return;    sh = getenv("SHELL");    if (sh == 0)        sh = "/bin/sh";    switch (fork()) {    case 0:		/* Child. */        close(ConnectionNumber(dpy));        if (screen && screen->display_spec != 0)            putenv(screen->display_spec);        execl(sh, sh, "-c", command, NULL);        fprintf(stderr, "%s: can't exec /"%s -c %s/"/n", argv0, sh,                command);        execlp("xterm", "xterm", NULL);        exit(EXIT_FAILURE);    case -1:	/* Error. */        fprintf(stderr, "%s: couldn't fork/n", argv0);        break;    }}

/* * Open up the mouse device. * Returns the fd if successful, or negative if unsuccessful. */static int X11_Open(MOUSEDEVICE *pmd){    if (x11_setup_display() < 0)	return -1;    /* return the x11 file descriptor for select */    return ConnectionNumber(x11_dpy);  }

// spawn() heavily inspired by dwm.cint spawn(int argc, char** argv) {    if (argc < 2) {        return HERBST_NEED_MORE_ARGS;    }    if (fork() == 0) {        // only look in child        if (g_display) {            close(ConnectionNumber(g_display));        }        // shift all args in argv by 1 to the front        // so that we have space for a NULL entry at the end for execvp        char** execargs = argv_duplicate(argc, argv);        free(execargs[0]);        int i;        for (i = 0; i < argc-1; i++) {            execargs[i] = execargs[i+1];        }        execargs[i] = NULL;        // do actual exec        setsid();        execvp(execargs[0], execargs);        fprintf(stderr, "herbstluftwm: execvp /"%s/"", argv[1]);        perror(" failed");        exit(0);    }    return 0;}

static bool MyXNextEventWithDelay(Display* dsp, XEvent* evt) {    // Check for pending events before entering the select loop. There might    // be events in the in-memory queue but not processed yet.    if (XPending(dsp)) {        XNextEvent(dsp, evt);        return true;    }    SkMSec ms = gTimerDelay;    if (ms > 0) {        int x11_fd = ConnectionNumber(dsp);        fd_set input_fds;        FD_ZERO(&input_fds);        FD_SET(x11_fd, &input_fds);        timeval tv;        tv.tv_sec = ms / 1000;              // seconds        tv.tv_usec = (ms % 1000) * 1000;    // microseconds        if (!select(x11_fd + 1, &input_fds, NULL, NULL, &tv)) {            if (!XPending(dsp)) {                return false;            }        }    }    XNextEvent(dsp, evt);    return true;}

int exec(char *type, char *device, char *status, char *name){	pid_t pid;	syslog(LOG_DEBUG, "Calling %s %s %s %s %s", cmd, type, device, status, name ? name : "");	pid = fork();	if (!pid) {		char *args[] = {			cmd,			type,			device,			status,			name ? name : "",			NULL		};		setsid();		if (display)			close(ConnectionNumber(display));		execv(args[0], args);		syslog(LOG_ERR, "Failed calling %s: %s", cmd, strerror(errno));		exit(0);	}	syslog(LOG_DEBUG, "Started %s as PID %d", cmd, pid);	return 0;}

static int get_next_x11_event(XEvent *xev){    int available = 0;    pXFlush(display);    if (pXEventsQueued(display, QueuedAlready))        available = 1;    else    {        /* XPending() blocks if there's no data, so select() first. */        struct timeval nowait;        const int fd = ConnectionNumber(display);        fd_set fdset;        FD_ZERO(&fdset);        FD_SET(fd, &fdset);        memset(&nowait, '/0', sizeof (nowait));        if (select(fd+1, &fdset, NULL, NULL, &nowait) == 1)            available = pXPending(display);    } /* else */    if (available)    {        memset(xev, '/0', sizeof (*xev));        pXNextEvent(display, xev);        return 1;    } /* if */    return 0;} /* get_next_x11_event */

int x11_shadow_subsystem_base_init(x11ShadowSubsystem* subsystem){	if (subsystem->display)		return 1; /* initialize once */	if (!getenv("DISPLAY"))		setenv("DISPLAY", ":0", 1);	if (!XInitThreads())		return -1;	subsystem->display = XOpenDisplay(NULL);	if (!subsystem->display)	{		WLog_ERR(TAG, "failed to open display: %s", XDisplayName(NULL));		return -1;	}	subsystem->xfds = ConnectionNumber(subsystem->display);	subsystem->number = DefaultScreen(subsystem->display);	subsystem->screen = ScreenOfDisplay(subsystem->display, subsystem->number);	subsystem->depth = DefaultDepthOfScreen(subsystem->screen);	subsystem->width = WidthOfScreen(subsystem->screen);	subsystem->height = HeightOfScreen(subsystem->screen);	subsystem->root_window = RootWindow(subsystem->display, subsystem->number);	return 1;}

void_clutter_backend_x11_events_init (ClutterBackend *backend){  ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend);  GSource *source;  ClutterEventSource *event_source;  int connection_number;  gchar *name;  connection_number = ConnectionNumber (backend_x11->xdpy);  CLUTTER_NOTE (EVENT, "Connection number: %d", connection_number);  source = backend_x11->event_source = clutter_event_source_new (backend);  event_source = (ClutterEventSource *) source;  g_source_set_priority (source, CLUTTER_PRIORITY_EVENTS);  name = g_strdup_printf ("Clutter X11 Event (connection: %d)",                          connection_number);  g_source_set_name (source, name);  g_free (name);  event_source->event_poll_fd.fd = connection_number;  event_source->event_poll_fd.events = G_IO_IN;  event_sources = g_list_prepend (event_sources, event_source);  g_source_add_poll (source, &event_source->event_poll_fd);  g_source_set_can_recurse (source, TRUE);  g_source_attach (source, NULL);}

//----------------------------------------------------------------------------------------------------------------------// X11_Pending - from SDL//----------------------------------------------------------------------------------------------------------------------static int X11_Pending(Display *display){   VOGL_FUNC_TRACER   /* Flush the display connection and look to see if events are queued */   XFlush(display);   if (XEventsQueued(display, QueuedAlready))   {      return(1);   }   /* More drastic measures are required -- see if X is ready to talk */   {      static struct timeval zero_time;	/* static == 0 */      int x11_fd;      fd_set fdset;      x11_fd = ConnectionNumber(display);      FD_ZERO(&fdset);      FD_SET(x11_fd, &fdset);      if (select(x11_fd+1, &fdset, NULL, NULL, &zero_time) == 1)      {         return(XPending(display));      }   }   /* Oh well, nothing is ready .. */   return(0);}

bool xorg::testing::XServer::WaitForEvent(::Display *display, time_t timeout){    fd_set fds;    FD_ZERO(&fds);    int display_fd = ConnectionNumber(display);    XSync(display, False);    if (XPending(display))        return true;    else {        FD_SET(display_fd, &fds);        struct timeval timeval = {            static_cast<time_t>(timeout / 1000),            static_cast<time_t>(timeout % 1000) * 1000,        };        int ret;        if (timeout)            ret = select(display_fd + 1, &fds, NULL, NULL, &timeval);        else            ret = select(display_fd + 1, &fds, NULL, NULL, NULL);        if (ret < 0)            throw std::runtime_error("Failed to select on X fd");        if (ret == 0)            return false;        return XPending(display);    }}

void Delay (int DTime){   fd_set f;   struct timeval timeout;   int cn;   XEvent xe;   if (key>=0) return;   if (XCheckMaskEvent(dpy,KeyPressMask,&xe)) {      process_event(&xe);      if (key>=0) return;   }   if (drawcounter>0) {      XClearWindow(dpy,w);      XFlush(dpy);      drawcounter=0;   }   timeout.tv_sec=DTime/1000;   timeout.tv_usec=1000*(DTime%1000);   FD_ZERO(&f);   cn=ConnectionNumber(dpy);   FD_SET(cn, &f);   select(cn+1, &f, 0, 0, &timeout);      /* note: the above implements a delay that is interrupted as      soon as an X event occurs, a keypress/release in all practical      cases. Interrupting the waiting upon keypress/release gives      much smoother behaviour with puff.   */}

extern "C" void signalHandler(int signal){#ifdef Q_WS_X11    // Kill window since it's frozen anyway.    if (QX11Info::display())        close(ConnectionNumber(QX11Info::display()));#endif    pid_t pid = fork();    switch (pid) {    case -1: // error        break;    case 0: // child        if (disableRestartOptionC) {            execl(crashHandlerPathC, crashHandlerPathC, strsignal(signal), appNameC,                  disableRestartOptionC, (char *) 0);        } else {            execl(crashHandlerPathC, crashHandlerPathC, strsignal(signal), appNameC, (char *) 0);        }        _exit(EXIT_FAILURE);    default: // parent        prctl(PR_SET_PTRACER, pid, 0, 0, 0);        waitpid(pid, 0, 0);        _exit(EXIT_FAILURE);        break;    }}

void spawn(Display * disp, const char** com){    if (fork()) return;    if (disp) close(ConnectionNumber(disp));    setsid();    execvp((char*)com[0], (char**)com);}

/* * Enter a loop processing X events & polling chars until we see a result */static void serverWait(VimRemotingClient *client, Window w, VimRemotingClient_EndCond endCond, void *endData, int seconds){    time_t            start;    time_t            now;    time_t            lastChk = 0;    XEvent            event;    XPropertyEvent *e = (XPropertyEvent *)&event;    int fd = ConnectionNumber(client->dpy);    time(&start);    while (!endCond(endData)) {        time(&now);        /* Just look out for the answer without calling back into Vim */        pollFor(fd, ((start + seconds) - now) * 1000);        if (!isWindowValid(client, w))            break;        while (XEventsQueued(client->dpy, QueuedAfterReading) > 0) {            XNextEvent(client->dpy, &event);            if (event.type == PropertyNotify &&                    e->window == client->window) {                serverEventProc(client, &event);            }        }    }}

LOCAL_SYMBOL MetaEventQueue*meta_event_queue_new (Display *display, MetaEventQueueFunc func, gpointer data){  GSource *source;  MetaEventQueue *eq;  source = g_source_new (&eq_funcs, sizeof (MetaEventQueue));  eq = (MetaEventQueue*) source;    eq->connection_fd = ConnectionNumber (display);  eq->poll_fd.fd = eq->connection_fd;  eq->poll_fd.events = G_IO_IN;  eq->events = g_queue_new ();  eq->display = display;    g_source_set_priority (source, G_PRIORITY_DEFAULT);  g_source_add_poll (source, &eq->poll_fd);  g_source_set_can_recurse (source, TRUE);  g_source_set_callback (source, (GSourceFunc) func, data, NULL);    g_source_attach (source, NULL);  g_source_unref (source);  return eq;}

	bool DisplayMessageQueue_X11::process(int timeout_ms)	{		auto end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout_ms);		while (true)		{			process_message();			process_queued_events(); // What is this? If its related to Event then it should be removed			process_window_sockets(); // Same for this thing			if (end_time <= std::chrono::steady_clock::now())				break;			int x11_handle = ConnectionNumber(display);			struct timeval tv;			if (timeout_ms > 0)			{				tv.tv_sec = timeout_ms / 1000;				tv.tv_usec = (timeout_ms % 1000) * 1000;			}			else if (timeout_ms == 0)			{				tv.tv_sec = 0;				tv.tv_usec = 0;			}			else			{				tv.tv_sec = 0x7FFFFFFF;				tv.tv_usec = 0;			}			fd_set rfds;			FD_ZERO(&rfds);			FD_SET(x11_handle, &rfds);			FD_SET(async_work_event.read_fd(), &rfds);			FD_SET(exit_event.read_fd(), &rfds);			int result = select(std::max(std::max(async_work_event.read_fd(), x11_handle), exit_event.read_fd()) + 1, &rfds, nullptr, nullptr, &tv);			if (result > 0)			{				if (FD_ISSET(async_work_event.read_fd(), &rfds))				{					async_work_event.reset();					process_async_work();				}				if (FD_ISSET(exit_event.read_fd(), &rfds))				{					exit_event.reset();					return false;				}			}			else			{				break;			}		}		return true;	}

voidspawn(ScreenInfo *s, void (*fn)()){    /*     * ugly dance to cause sweeping for terminals.     * the very next window created will require sweeping.     * hope it's created by the program we're about to     * exec!     */    isNew = 1;    /*     * ugly dance to avoid leaving zombies. Could use SIGCHLD,     * but it's not very portable.     */    if(fork() == 0) {        if(fork() == 0) {            close(ConnectionNumber(dpy));            if(s->display[0] != '/0')                putenv(s->display);            signal(SIGINT, SIG_DFL);            signal(SIGTERM, SIG_DFL);            signal(SIGHUP, SIG_DFL);            fn();            exit(1);        }        exit(0);    }    wait((int *) 0);}

    void Application::run(int argc, char *argv[])    {      DOUT("Application::run()");      ApplicationEventPtr applicationEvent = ApplicationEvent::create(ApplicationEvent::RUN());      eventDispatcher->dispatchEvent(applicationEvent);      XEvent event;            int fd = ConnectionNumber(hiddenMembers->display);      while(running) {        XFlush(hiddenMembers->display);        struct timeval tv;        fd_set rfds;        FD_ZERO(&rfds);        FD_SET(fd,&rfds);        memset(&tv,0,sizeof(tv));        tv.tv_usec = 100000; /* delay in microseconds = 100 milliseconds */        if (select(fd+1,&rfds,0,0,&tv) > 0) {          XSync(hiddenMembers->display, False);                  while(XEventsQueued(hiddenMembers->display, QueuedAlready) > 0) {            XNextEvent(hiddenMembers->display, &event);            switch (event.type) {                            case ClientMessage:                if (event.xclient.data.l[0] == hiddenMembers->WM_WAKEUP) {                  DOUT("wakeup!");                  break;                }                              default:                if (event.xclient.window) {                  linux_::WindowHandler* windowHandler = NULL;                  if (xWindows.find(event.xclient.window) != xWindows.end()) {                    windowHandler = xWindows[event.xclient.window];                  }                                    if (windowHandler != NULL) {                    windowHandler->handleEvent(event);                  }                }                break;                            }            XFlush(hiddenMembers->display);          }        }        eventDispatcher->processEvents();      }    }