VdpStatus vdp_imp_device_create_x11(Display *display,
int screen,
VdpDevice *device,
VdpGetProcAddress **get_proc_address)
{
if (!display || !device || !get_proc_address)
return VDP_STATUS_INVALID_POINTER;
device_ctx_t *dev = handle_create(sizeof(*dev), device);
if (!dev)
return VDP_STATUS_RESOURCES;
dev->display = XOpenDisplay(XDisplayString(display));
dev->screen = screen;
if (!ve_open())
{
handle_destroy(*device);
return VDP_STATUS_ERROR;
}
char *env_vdpau_osd = getenv("VDPAU_OSD");
if (env_vdpau_osd && strncmp(env_vdpau_osd, "1", 1) == 0)
{
dev->g2d_fd = open("/dev/g2d", O_RDWR);
if (dev->g2d_fd != -1)
dev->osd_enabled = 1;
else
VDPAU_DBG("Failed to open /dev/g2d! OSD disabled.");
}
*get_proc_address = vdp_get_proc_address;
return VDP_STATUS_OK;
}
XtEnum XmPrintToFile(Display *pdpy,
char *file_name,
XPFinishProc finish_proc,
XPointer client_data)
{
FileCallbackRec *callback;
int pid;
XPContext pcontext ;
String application_name, application_class, display_name;
FILE *file;
int filedes[2];
/* make sure we can open the file for writing */
if ((file = fopen(file_name, "w")) == NULL) {
return False;
}
if ((pipe(filedes)) == -1) {
return False;
}
/* its important to flush before we fork, to make sure that the
XpStartJob gets through first in the parent */
XFlush(pdpy);
XtGetApplicationNameAndClass(pdpy,
&application_name, &application_class);
display_name = XDisplayString(pdpy) ;
pcontext = XpGetContext(pdpy) ;
pid = fork();
if (pid == 0) {
ChildPrintToFile(display_name, pcontext, file, file_name, filedes[1],
application_name, application_class);
}
else if (pid < 0) {
return False;
}
/* we are in the parent */
fclose(file);
close(filedes[1]);
/* allocate the space for a callback */
callback = (FileCallbackRec *) XtMalloc(sizeof(FileCallbackRec));
callback->display = pdpy;
callback->pipe = filedes[0];
callback->finish_proc = finish_proc;
callback->client_data = client_data;
/* notification that the child has completed */
callback->input_id =
XtAppAddInput(XtDisplayToApplicationContext(pdpy),
callback->pipe, (XtPointer)XtInputReadMask,
FilePipeCB, callback);
return True;
}
static void
gst_vaapi_display_x11_constructed(GObject *object)
{
GstVaapiDisplayX11 * const display = GST_VAAPI_DISPLAY_X11(object);
GstVaapiDisplayX11Private * const priv = display->priv;
GstVaapiDisplayCache * const cache = gst_vaapi_display_get_cache();
const GstVaapiDisplayInfo *info;
GObjectClass *parent_class;
priv->create_display = priv->x11_display == NULL;
/* Don't create X11 display if there is one in the cache already */
if (priv->create_display) {
info = gst_vaapi_display_cache_lookup_by_name(
cache,
priv->display_name,
compare_display_name, NULL
);
if (info) {
priv->x11_display = info->native_display;
priv->create_display = FALSE;
}
}
/* Reset display-name if the user provided his own X11 display */
if (!priv->create_display)
set_display_name(display, XDisplayString(priv->x11_display));
parent_class = G_OBJECT_CLASS(gst_vaapi_display_x11_parent_class);
if (parent_class->constructed)
parent_class->constructed(object);
}
void CloneDisplay(Display *dpy)
{
if(CurrentXDisplay || dpy == NULL)
return;
CurrentXDisplay = XOpenDisplay(XDisplayString(dpy));
}
int ftr_loop_run2(struct FTR *ff, struct FTR *gg)
{
struct _FTR *f = (void*)ff;
struct _FTR *g = (void*)gg;
char *dn_f = XDisplayString(f->display);
char *dn_g = XDisplayString(g->display);
if (0 != strcmp(dn_f, dn_g))
exit(fprintf(stderr, "FTR error: two displays bad bad bad (%p,%p)(\"%s\",\"%s\")\n", (void*)f->display, (void*)g->display, dn_f, dn_g));
fprintf(stderr, "dn_f = %p \"%s\"\n", (void*)f->display, dn_f);
fprintf(stderr, "dn_g = %p \"%s\"\n", (void*)g->display, dn_g);
while (!f->stop_loop && !g->stop_loop)
{
int pending_f = XPending(f->display);
int pending_g = XPending(g->display);
fprintf(stderr, "pending fg = %d %d\n", pending_f, pending_g);
// treat g
if (!g->handle_idle || g->changed || pending_g > 0)
process_next_event(gg);
else if (g->handle_idle) {
g->handle_idle(gg, 0, 0, 0, 0);
XEvent ev;
ev.type = Expose;
XSendEvent(g->display, g->window, 0, NoEventMask, &ev);
XFlush(g->display);
}
// treat f
if (!f->handle_idle || f->changed || pending_f > 0)
process_next_event(ff);
else if (f->handle_idle) {
f->handle_idle(ff, 0, 0, 0, 0);
XEvent ev;
ev.type = Expose;
XSendEvent(f->display, f->window, 0, NoEventMask, &ev);
XFlush(f->display);
}
}
int r = f->stop_loop + g->stop_loop;
f->stop_loop = g->stop_loop = 0;
return r;
}
/*
* fetch and/or set the ATOM_PAIRS. This is triggered at least once
* by the first call to XmInternAtom().
*/
extern void
_XmInitAtomPairs(Display *display)
{
Window win;
char *dstr;
Display *d;
DEBUGOUT(_LtDebug0(__FILE__, NULL, "%s:_XmInitAtomPairs(%d)\n",
__FILE__, __LINE__));
if ((win = read_drag_window(display)) == None)
{
dstr = XDisplayString(display);
d = XOpenDisplay(dstr);
if (d == NULL)
{
_XmWarning((Widget)XmGetXmDisplay(display),
"Where's your display?");
return;
}
XGrabServer(d);
if ((win = read_drag_window(d)) == None)
{
XSetCloseDownMode(d, RetainPermanent);
win = create_drag_window(d);
write_drag_window(d, &win);
}
XCloseDisplay(d);
}
set_drag_window(display, win);
if (!read_atom_pairs(display))
{
XGrabServer(display);
if (!read_atom_pairs(display))
{
write_atom_pairs(display);
}
XUngrabServer(display);
XFlush(display);
}
}
string _sh_command(string command, bool force_local,
bool force_display_settings)
{
// Fetch display settings
string display;
if (command_shell != 0)
display = XDisplayString(XtDisplay(command_shell));
else if (getenv("DISPLAY") != 0)
display = getenv("DISPLAY");
else
display = "";
// Make sure display contains host name
if (display.contains("unix:", 0) || display.contains(":", 0))
{
display = string(hostname()) + display.from(":");
}
// Make sure display contains fully qualified host name
if (display.contains(":") && !display.contains("::"))
{
string host = display.before(':');
display = string(fullhostname(host.chars())) + display.from(":");
}
string settings = "";
if (!display.empty())
{
settings +=
"DISPLAY=${DISPLAY-" + sh_quote(display) + "}; export DISPLAY; ";
}
settings += set_environment_command();
if (force_local || !remote_gdb())
{
if (command.empty())
return "";
if (force_display_settings)
command = settings + command;
return "/bin/sh -c " + sh_quote(command);
}
string rsh = app_data.rsh_command;
const string login = app_data.debugger_host_login;
if (!login.empty())
rsh += " -l " + login;
rsh += " " + gdb_host;
if (!command.empty())
rsh += " /bin/sh -c " + sh_quote(sh_quote(settings + command));
return rsh;
}
void
logoutUser(Display * display
#ifdef CLOSEDOWN_LOGOUT
, int screens
#endif
)
{
#if ( HAVE_SYSLOG_H && defined( USE_SYSLOG ))
syslog(SYSLOG_INFO, "%s: expired. closing down (uid %d) on %s\n",
ProgramName, getuid(), getenv("DISPLAY"));
syslogStop(XDisplayString(display));
#endif
if (logoutCmd && *logoutCmd) {
int cmd_pid;
if ((cmd_pid = (int) FORK()) == -1) {
(void) fprintf(stderr, "Failed to launch \"%s\"\n", logoutCmd);
perror(ProgramName);
cmd_pid = 0;
} else if (!cmd_pid) {
(void) system(logoutCmd);
exit(0);
}
}
#ifdef CLOSEDOWN_LOGOUT
(void) finish(display, False);
#else
(void) finish(display, True);
#endif
#ifdef VMS
(void) system("mcr decw$endsession -noprompt");
#else
#ifdef __sgi
(void) system("/usr/bin/X11/tellwm end_session >/dev/null 2>&1");
(void) sleep(10); /* Give the above a chance to run */
#endif
#endif
#ifdef CLOSEDOWN_LOGOUT
/* Do not want to kill other user's processes e.g. telnet session */
closedownLogout(display, screens);
return;
#endif
#ifdef SESSION_LOGOUT
sessionLogout();
#endif
uglyLogout();
exit(-1);
}
void cleanDisplay ( Display * display,
int n )
{
oyOptions_s * opts = 0,
* result = 0;
const char * display_name = strdup(XDisplayString(display));
oyOptions_SetFromText( &opts, "////display_name",
display_name, OY_CREATE_NEW );
oyOptions_Handle( "//" OY_TYPE_STD "/clean_profiles",
opts,"clean_profiles",
&result );
}
static int match_display_name(Display *x11_dpy, const char *display_name)
{
Display *test_dpy;
char *test_dpy_name, *x11_dpy_name;
int test_dpy_namelen, x11_dpy_namelen;
int m;
test_dpy = XOpenDisplay(display_name);
if (!test_dpy)
return 0;
test_dpy_name = XDisplayString(test_dpy);
test_dpy_namelen = get_display_name_length(test_dpy_name);
x11_dpy_name = XDisplayString(x11_dpy);
x11_dpy_namelen = get_display_name_length(x11_dpy_name);
m = (test_dpy_namelen == x11_dpy_namelen &&
(test_dpy_namelen == 0 ||
(test_dpy_namelen > 0 &&
strncmp(test_dpy_name, x11_dpy_name, test_dpy_namelen) == 0)));
XCloseDisplay(test_dpy);
return m;
}
static int xext_errhandler(Display *d, _Xconst char *ext, _Xconst char *reason)
{
#ifdef X11_DEBUG
printf("Xext error inside SDL (may be harmless):\n");
printf(" Extension \"%s\" %s on display \"%s\".\n",
ext, reason, XDisplayString(d));
#endif
if (SDL_strcmp(reason, "missing") == 0) {
return 0;
}
return Xext_handler(d, ext, reason);
}
XRecordKeyboardMonitor::XRecordKeyboardMonitor(Display *display)
: m_connection(xcb_connect(XDisplayString(display), 0)),
m_modifiersPressed(0), m_keysPressed(0)
{
if (!m_connection) {
return;
}
xcb_get_modifier_mapping_cookie_t modmapCookie =
xcb_get_modifier_mapping(m_connection);
m_context = xcb_generate_id(m_connection);
xcb_record_range_t range;
memset(&range, 0, sizeof(range));
range.device_events.first = XCB_KEY_PRESS;
range.device_events.last = XCB_KEY_RELEASE;
xcb_record_client_spec_t cs = XCB_RECORD_CS_ALL_CLIENTS;
xcb_record_create_context(m_connection, m_context, 0, 1, 1, &cs, &range);
xcb_flush(m_connection);
QScopedPointer<xcb_get_modifier_mapping_reply_t, QScopedPointerPodDeleter>
modmap(xcb_get_modifier_mapping_reply(m_connection, modmapCookie, 0));
if (!modmap) {
return;
}
int nModifiers = xcb_get_modifier_mapping_keycodes_length(modmap.data());
xcb_keycode_t *modifiers = xcb_get_modifier_mapping_keycodes(modmap.data());
m_modifier.fill(false, std::numeric_limits<xcb_keycode_t>::max() + 1);
for (xcb_keycode_t *i = modifiers; i < modifiers + nModifiers; i++) {
m_modifier[*i] = true;
}
m_ignore.fill(false, std::numeric_limits<xcb_keycode_t>::max() + 1);
for (xcb_keycode_t *i = modifiers;
i < modifiers + modmap->keycodes_per_modifier; i++)
{
m_ignore[*i] = true;
}
m_pressed.fill(false, std::numeric_limits<xcb_keycode_t>::max() + 1);
m_cookie = xcb_record_enable_context(m_connection, m_context);
xcb_flush(m_connection);
m_notifier = new QSocketNotifier(xcb_get_file_descriptor(m_connection),
QSocketNotifier::Read, this);
connect(m_notifier, SIGNAL(activated(int)), SLOT(processNextReply()));
m_notifier->setEnabled(true);
}
QT_BEGIN_NAMESPACE
XCompositeHandler::XCompositeHandler(QWaylandCompositor *compositor, Display *display)
: QtWaylandServer::qt_xcomposite(compositor->display(), 1)
{
mFakeRootWindow = new QWindow();
mFakeRootWindow->setGeometry(QRect(-1,-1,1,1));
mFakeRootWindow->create();
mFakeRootWindow->show();
int composite_event_base, composite_error_base;
if (!XCompositeQueryExtension(display, &composite_event_base, &composite_error_base))
qFatal("XComposite required");
mDisplayString = QString::fromLocal8Bit(XDisplayString(display));
}
static void
gst_vaapi_display_x11_constructed(GObject *object)
{
GstVaapiDisplayX11 * const display = GST_VAAPI_DISPLAY_X11(object);
GObjectClass *parent_class;
display->priv->create_display = display->priv->x11_display == NULL;
/* Reset display-name if the user provided his own X11 display */
if (!display->priv->create_display)
set_display_name(display, XDisplayString(display->priv->x11_display));
parent_class = G_OBJECT_CLASS(gst_vaapi_display_x11_parent_class);
if (parent_class->constructed)
parent_class->constructed(object);
}
static gboolean
gst_vaapi_display_x11_bind_display (GstVaapiDisplay * base_display,
gpointer native_display)
{
GstVaapiDisplayX11 *const display = GST_VAAPI_DISPLAY_X11_CAST (base_display);
GstVaapiDisplayX11Private *const priv = display->priv;
priv->x11_display = native_display;
priv->x11_screen = DefaultScreen (native_display);
priv->use_foreign_display = TRUE;
check_extensions (display);
if (!set_display_name (display, XDisplayString (priv->x11_display)))
return FALSE;
return TRUE;
}
static
void *XpuPrintToFile( Display *pdpy, XPContext pcontext, const char *filename )
{
MyPrintFileData *mpfd; /* warning: shared between threads !! */
if( (mpfd = malloc(sizeof(MyPrintFileData))) == NULL )
return(NULL);
mpfd->parent_pdpy = pdpy;
mpfd->displayname = XDisplayString(pdpy);
mpfd->pdpy = NULL;
mpfd->pcontext = pcontext;
mpfd->file_name = filename;
mpfd->file = NULL;
mpfd->status = XPGetDocError;
/* make sure we can open the file for writing */
if( (mpfd->file = fopen(mpfd->file_name, "w")) == NULL )
{
/* fopen() error */
free(mpfd);
return(NULL);
}
/* its important to flush before we start the consumer thread,
* to make sure that the XpStartJob gets through first in the parent
*/
XFlush(pdpy);
#ifdef XPU_USE_NSPR
if( (mpfd->prthread = PR_CreateThread(PR_SYSTEM_THREAD, PrintToFile_Consumer, mpfd, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0)) == NULL )
#else
if( pthread_create(&(mpfd->tid), NULL, PrintToFile_Consumer, mpfd) != 0 )
#endif
{
/* pthread_create() error */
fclose(mpfd->file);
free(mpfd);
return(NULL);
}
/* we're still in the parent */
XPU_DEBUG_ONLY(printf("### parent started consumer thread.\n" ));
return(mpfd);
}
void *
handle_xdpy_ref(void *dpy_orig)
{
pthread_mutex_lock(&lock);
Display *dpy = g_hash_table_lookup(xdpy_copies, dpy_orig);
if (NULL == dpy) {
dpy = XOpenDisplay(XDisplayString(dpy_orig));
if (!dpy)
goto quit;
g_hash_table_replace(xdpy_copies, dpy_orig, dpy);
g_hash_table_replace(xdpy_copies_refcount, dpy_orig, GINT_TO_POINTER(1));
} else {
int refcount = GPOINTER_TO_INT(g_hash_table_lookup(xdpy_copies_refcount, dpy_orig));
g_hash_table_replace(xdpy_copies_refcount, dpy_orig, GINT_TO_POINTER(refcount+1));
}
quit:
pthread_mutex_unlock(&lock);
return dpy;
}
static int vdpau_device_create(AVHWDeviceContext *ctx, const char *device,
AVDictionary *opts, int flags)
{
AVVDPAUDeviceContext *hwctx = ctx->hwctx;
VDPAUDevicePriv *priv;
VdpStatus err;
VdpGetInformationString *get_information_string;
const char *display, *vendor;
priv = av_mallocz(sizeof(*priv));
if (!priv)
return AVERROR(ENOMEM);
ctx->user_opaque = priv;
ctx->free = vdpau_device_free;
priv->dpy = XOpenDisplay(device);
if (!priv->dpy) {
av_log(ctx, AV_LOG_ERROR, "Cannot open the X11 display %s.\n",
XDisplayName(device));
return AVERROR_UNKNOWN;
}
display = XDisplayString(priv->dpy);
err = vdp_device_create_x11(priv->dpy, XDefaultScreen(priv->dpy),
&hwctx->device, &hwctx->get_proc_address);
if (err != VDP_STATUS_OK) {
av_log(ctx, AV_LOG_ERROR, "VDPAU device creation on X11 display %s failed.\n",
display);
return AVERROR_UNKNOWN;
}
GET_CALLBACK(VDP_FUNC_ID_GET_INFORMATION_STRING, get_information_string);
GET_CALLBACK(VDP_FUNC_ID_DEVICE_DESTROY, priv->device_destroy);
get_information_string(&vendor);
av_log(ctx, AV_LOG_VERBOSE, "Successfully created a VDPAU device (%s) on "
"X11 display %s\n", vendor, display);
return 0;
}
static int xext_errhandler(Display *d, _Xconst char *ext, _Xconst char *reason)
{
#ifdef X11_DEBUG
printf("Xext error inside SDL (may be harmless):\n");
printf(" Extension \"%s\" %s on display \"%s\".\n",
ext, reason, XDisplayString(d));
#endif
if (SDL_strcmp(reason, "missing") == 0) {
/*
* Since the query itself, elsewhere, can handle a missing extension
* and the default behaviour in Xlib is to write to stderr, which
* generates unnecessary bug reports, we just ignore these.
*/
return 0;
}
/* Everything else goes to the default handler... */
return Xext_handler(d, ext, reason);
}
static bool localDisplay(Display *dpy)
{
QByteArray display(XDisplayString(dpy));
QByteArray hostPart = display.left(display.indexOf(':'));
if (hostPart.isEmpty())
return true;
if (hostPart == "localhost")
return true;
if (hostPart == "127.0.0.1")
return true;
char name[2048];
gethostname(name, sizeof(name));
if (hostPart == name)
return true;
return false;
}
static void
bus_test_client_class_init (BusTestClientClass *klass)
{
IDEBUG ("%s", __FUNCTION__);
IBusObjectClass *ibus_object_class = IBUS_OBJECT_CLASS (klass);
ibus_object_class->destroy = bus_test_client_destroy;
/* init display object */
if (_xdisplay == NULL) {
_xdisplay = XOpenDisplay (gdk_display_get_name (gdk_display_get_default ()));
}
/* init bus object */
if (_bus == NULL) {
ibus_set_display (XDisplayString (_xdisplay));
_bus = ibus_bus_new();
}
g_signal_connect (_bus, "disconnected", G_CALLBACK (_bus_disconnected_cb), NULL);
}
int FcitxQtConnectionPrivate::displayNumber() {
if (m_displayNumber >= 0)
return m_displayNumber;
Display * dpy = QX11Info::display();
int displayNumber = 0;
if (dpy) {
char* display = XDisplayString(dpy);
if (display) {
char* strDisplayNumber = NULL;
display = strdup(display);
char* p = display;
for (; *p != ':' && *p != '\0'; p++);
if (*p == ':') {
*p = '\0';
p++;
strDisplayNumber = p;
}
for (; *p != '.' && *p != '\0'; p++);
if (*p == '.') {
*p = '\0';
}
if (strDisplayNumber) {
displayNumber = atoi(strDisplayNumber);
}
free(display);
}
}
else
displayNumber = fcitx_utils_get_display_number();
m_displayNumber = displayNumber;
return displayNumber;
}
int main(int argc, char **argv)
{
unsigned long valuemask; /* mask for create windows */
XSetWindowAttributes attributes; /* attributes for create windows */
void InternUsefulAtoms(void);
void InitVariables(void);
int i, len;
extern int x_fd;
char *display_string;
char message[255];
Bool single = False;
Bool option_error = FALSE;
MenuRoot *mr;
g_argv = argv;
g_argc = argc;
OpenConsole();
DBUG("main", "Entered, about to parse args");
for (i = 1; i < argc; i++) {
if (strncasecmp(argv[i], "-debug", 6) == 0) {
debugging = True;
} else if (strncasecmp(argv[i], "-s", 2) == 0) {
single = True;
} else if (strncasecmp(argv[i], "-d", 2) == 0) {
if (++i >= argc)
usage();
display_name = argv[i];
} else if (strncasecmp(argv[i], "-f", 2) == 0) {
if (++i >= argc)
usage();
config_command = (char *) malloc(6 + strlen(argv[i]));
strcpy(config_command, "Read ");
strcat(config_command, argv[i]);
free_config_command = True;
} else if (strncasecmp(argv[i], "-cmd", 4) == 0) {
if (++i >= argc)
usage();
config_command = argv[i];
} else if (strncasecmp(argv[i], "-file", 5) == 0) {
if (++i >= argc)
usage();
output_file = argv[i];
} else if (strncasecmp(argv[i], "-h", 2) == 0) {
usage();
exit(0);
} else if (strncasecmp(argv[i], "-blackout", 9) == 0) {
Blackout = True;
} else if (strncasecmp(argv[i], "-version", 8) == 0) {
fvwm_msg(INFO, "main", "Fvwm95 Version %s compiled on %s at %s\n",
VERSION, __DATE__, __TIME__);
} else {
fvwm_msg(ERR, "main", "Unknown option: `%s'\n", argv[i]);
option_error = TRUE;
}
}
DBUG("main", "Done parsing args");
if (option_error) {
usage();
}
DBUG("main", "Installing signal handlers");
newhandler(SIGINT);
newhandler(SIGHUP);
newhandler(SIGQUIT);
newhandler(SIGTERM);
signal(SIGUSR1, Restart);
signal(SIGPIPE, DeadPipe);
ReapChildren();
if (!(dpy = XOpenDisplay(display_name))) {
fvwm_msg(ERR, "main", "can't open display %s",
XDisplayName(display_name));
exit(1);
}
Scr.screen = DefaultScreen(dpy);
Scr.NumberOfScreens = ScreenCount(dpy);
master_pid = getpid();
if (!single) {
int myscreen = 0;
char *cp;
strcpy(message, XDisplayString(dpy));
XCloseDisplay(dpy);
for (i = 1; i < Scr.NumberOfScreens; i++) {
if (fork() == 0) {
myscreen = i;
break;
}
}
/*
* Truncate the string 'whatever:n.n' to 'whatever:n',
* and then append the screen number.
*/
cp = strchr(message, ':');
if (cp != NULL) {
cp = strchr(cp, '.');
if (cp != NULL)
*cp = '\0'; /* truncate at display part */
}
sprintf(message + strlen(message), ".%d", myscreen);
dpy = XOpenDisplay(message);
Scr.screen = myscreen;
Scr.NumberOfScreens = ScreenCount(dpy);
}
x_fd = XConnectionNumber(dpy);
fd_width = GetFdWidth();
if (fcntl(x_fd, F_SETFD, 1) == -1) {
fvwm_msg(ERR, "main", "close-on-exec failed");
exit(1);
}
/* Add a DISPLAY entry to the environment, in case we were started
* with fvwm -display term:0.0
*/
len = strlen(XDisplayString(dpy));
display_string = safemalloc(len + 10);
sprintf(display_string, "DISPLAY=%s", XDisplayString(dpy));
putenv(display_string);
/* Add a HOSTDISPLAY environment variable, which is the same as
* DISPLAY, unless display = :0.0 or unix:0.0, in which case the full
* host name will be used for ease in networking . */
/* Note: Can't free the rdisplay_string after putenv, because it
* becomes part of the environment! */
if (strncmp(display_string, "DISPLAY=:", 9) == 0) {
char client[MAXHOSTNAME], *rdisplay_string;
mygethostname(client, MAXHOSTNAME);
rdisplay_string = safemalloc(len + 14 + strlen(client));
sprintf(rdisplay_string, "HOSTDISPLAY=%s:%s", client,
&display_string[9]);
putenv(rdisplay_string);
} else if (strncmp(display_string, "DISPLAY=unix:", 13) == 0) {
char client[MAXHOSTNAME], *rdisplay_string;
mygethostname(client, MAXHOSTNAME);
rdisplay_string = safemalloc(len + 14 + strlen(client));
sprintf(rdisplay_string, "HOSTDISPLAY=%s:%s", client,
&display_string[13]);
putenv(rdisplay_string);
} else {
char *rdisplay_string;
rdisplay_string = safemalloc(len + 14);
sprintf(rdisplay_string, "HOSTDISPLAY=%s", XDisplayString(dpy));
putenv(rdisplay_string);
}
Scr.Root = RootWindow(dpy, Scr.screen);
if (Scr.Root == None) {
fvwm_msg(ERR, "main", "Screen %d is not a valid screen",
(char *) Scr.screen);
exit(1);
}
#ifdef SHAPE
ShapesSupported =
XShapeQueryExtension(dpy, &ShapeEventBase, &ShapeErrorBase);
#endif /* SHAPE */
InternUsefulAtoms();
/* Make sure property priority colors is empty */
XChangeProperty(dpy, Scr.Root, _XA_MIT_PRIORITY_COLORS,
XA_CARDINAL, 32, PropModeReplace, NULL, 0);
XSetErrorHandler((XErrorHandler) CatchRedirectError);
XSetIOErrorHandler((XIOErrorHandler) CatchFatal);
XSelectInput(dpy, Scr.Root,
LeaveWindowMask | EnterWindowMask | PropertyChangeMask |
SubstructureRedirectMask | KeyPressMask |
SubstructureNotifyMask |
ButtonPressMask | ButtonReleaseMask);
XSync(dpy, 0);
XSetErrorHandler((XErrorHandler) FvwmErrorHandler);
BlackoutScreen();
CreateCursors();
InitVariables();
InitEventHandlerJumpTable();
initModules();
InitPictureCMap(dpy, Scr.Root); /* for the pixmap cache... */
Scr.gray_bitmap =
XCreateBitmapFromData(dpy, Scr.Root, g_bits, g_width, g_height);
DBUG("main", "Setting up rc file defaults...");
SetRCDefaults();
DBUG("main", "Running config_command...");
ExecuteFunction(config_command, NULL, &Event, C_ROOT, -1);
DBUG("main", "Done running config_command");
/*
CaptureAllWindows();
MakeMenus();
*/
#if 0 /* this seems to cause problems for FvwmCpp/M4 startup actually */
/* if not a direct 'Read', we'll capture all windows here, in case cmd
fails we'll still have defaults */
if (strncasecmp(config_command, "Read", 4) != 0 &&
strncasecmp(config_command, "PipeRead", 8) != 0) {
/* so if cmd (FvwmM4/Cpp most likely) fails, we can still have
borders & stuff... */
StartupStuff();
}
#endif /* 0 */
if (free_config_command) {
free(config_command);
}
if (Scr.d_depth < 2) {
Scr.gray_pixmap =
XCreatePixmapFromBitmapData(dpy, Scr.Root, g_bits, g_width,
g_height, Scr.WinColors.fore,
Scr.WinColors.back, Scr.d_depth);
Scr.light_gray_pixmap =
XCreatePixmapFromBitmapData(dpy, Scr.Root, l_g_bits, l_g_width,
l_g_height, Scr.WinColors.fore,
Scr.WinColors.back, Scr.d_depth);
}
/* create a window which will accept the keyboard focus when no other
windows have it */
attributes.event_mask = KeyPressMask | FocusChangeMask;
attributes.override_redirect = True;
Scr.NoFocusWin = XCreateWindow(dpy, Scr.Root, -10, -10, 10, 10, 0, 0,
InputOnly, CopyFromParent,
CWEventMask | CWOverrideRedirect,
&attributes);
XMapWindow(dpy, Scr.NoFocusWin);
SetMWM_INFO(Scr.NoFocusWin);
XSetInputFocus(dpy, Scr.NoFocusWin, RevertToParent, CurrentTime);
XSync(dpy, 0);
if (debugging)
XSynchronize(dpy, 1);
Scr.SizeStringWidth = XTextWidth(Scr.StdFont.font,
" +8888 x +8888 ", 15);
attributes.border_pixel = Scr.WinColors.fore;
attributes.background_pixel = Scr.WinColors.back;
attributes.bit_gravity = NorthWestGravity;
attributes.save_under = True;
valuemask = (CWBorderPixel | CWBackPixel | CWBitGravity | CWSaveUnder);
/* create the window for coordinates */
Scr.SizeWindow = XCreateWindow(dpy, Scr.Root,
Scr.MyDisplayWidth / 2 -
(Scr.SizeStringWidth +
SIZE_HINDENT * 2) / 2,
Scr.MyDisplayHeight / 2 -
(Scr.StdFont.height +
SIZE_VINDENT * 2) / 2,
(unsigned int) (Scr.SizeStringWidth +
SIZE_HINDENT * 2),
(unsigned int) (Scr.StdFont.height +
SIZE_VINDENT * 2),
(unsigned int) 0, 0,
(unsigned int) CopyFromParent,
(Visual *) CopyFromParent,
valuemask, &attributes);
#ifndef NON_VIRTUAL
initPanFrames();
#endif
XGrabServer(dpy);
#ifndef NON_VIRTUAL
checkPanFrames();
#endif
XUngrabServer(dpy);
UnBlackoutScreen();
DBUG("main", "Entering HandleEvents loop...");
HandleEvents();
DBUG("main", "Back from HandleEvents loop? Exiting...");
return 0;
}
int
main(int argc, char * argv[])
{
int loop, num_extensions, num_devices;
char **extensions;
XDeviceInfo *devices;
Display *dpy;
Window root_win;
unsigned long screen;
int list = 0;
if (argc != 2) {
fprintf(stderr, "usage : %s (-l | <device name>)\n", argv[0]);
exit(1);
}
if (strcmp(argv[1], "-l") == 0) {
list = 1;
}
dpy = XOpenDisplay(NULL);
if (!dpy) {
printf("unable to connect to X Server try to set the DISPLAY variable\n");
exit(1);
}
#ifdef DEBUG
printf("connected to %s\n", XDisplayString(dpy));
#endif
screen = DefaultScreen(dpy);
root_win = RootWindow(dpy, screen);
extensions = XListExtensions(dpy, &num_extensions);
for (loop = 0; loop < num_extensions &&
(strcmp(extensions[loop], "XInputExtension") != 0); loop++);
XFreeExtensionList(extensions);
if (loop != num_extensions)
{
devices = XListInputDevices(dpy, &num_devices);
for(loop=0; loop<num_devices; loop++)
{
if (list) {
printf("\"%s\" [", devices[loop].name ? devices[loop].name : "<noname>");
switch(devices[loop].use) {
case IsXPointer:
printf("XPointer]\n");
break;
case IsXKeyboard:
printf("XKeyboard]\n");
break;
case IsXExtensionDevice:
printf("XExtensionDevice]\n");
break;
default:
printf("invalid value]\n");
break;
}
}
else {
if ((argc == 2) && devices[loop].name &&
(StrCaseCmp(devices[loop].name, argv[1]) == 0))
if (devices[loop].use == IsXExtensionDevice)
{
XDevice *device;
#ifdef DEBUG
fprintf(stderr, "opening device %s\n",
devices[loop].name ? devices[loop].name : "<noname>");
#endif
device = XOpenDevice(dpy, devices[loop].id);
if (device)
{
XChangePointerDevice(dpy, device, 0, 1);
exit(0);
}
else
{
fprintf(stderr, "error opening device\n");
exit(1);
}
}
}
}
XFreeDeviceList(devices);
}
else
{
fprintf(stderr, "No XInput extension available\n");
exit(1);
}
if (list) {
exit(0);
}
else {
fprintf(stderr, "Extended device %s not found\n", argv[1]);
exit(1);
}
}
int
main(int argc, char * argv[])
{
int loop, num_extensions, num_devices;
char **extensions;
XDeviceInfo *devices;
Display *dpy;
Window root_win;
unsigned long screen;
int list = 0;
if (argc != 3) {
fprintf(stderr, "usage : %s <device name> (ABSOLUTE|RELATIVE)\n", argv[0]);
exit(1);
}
if (strcmp(argv[1], "-l") == 0) {
list = 1;
}
dpy = XOpenDisplay(NULL);
if (!dpy) {
printf("unable to connect to X Server try to set the DISPLAY variable\n");
exit(1);
}
#ifdef DEBUG
printf("connected to %s\n", XDisplayString(dpy));
#endif
screen = DefaultScreen(dpy);
root_win = RootWindow(dpy, screen);
extensions = XListExtensions(dpy, &num_extensions);
for (loop = 0; loop < num_extensions &&
(strcmp(extensions[loop], "XInputExtension") != 0); loop++);
XFreeExtensionList(extensions);
if (loop != num_extensions)
{
devices = XListInputDevices(dpy, &num_devices);
for(loop=0; loop<num_devices; loop++)
{
if (devices[loop].name &&
(StrCaseCmp(devices[loop].name, argv[1]) == 0))
if (devices[loop].use == IsXExtensionDevice)
{
XDevice *device;
#ifdef DEBUG
fprintf(stderr, "opening device %s\n",
devices[loop].name ? devices[loop].name : "<noname>");
#endif
device = XOpenDevice(dpy, devices[loop].id);
if (device)
{
XSetDeviceMode(dpy, device, (strcmp("ABSOLUTE", argv[2]) == 0) ? Absolute
: Relative);
exit(0);
}
else
{
fprintf(stderr, "error opening device\n");
exit(1);
}
}
}
XFreeDeviceList(devices);
}
else
{
fprintf(stderr, "No XInput extension available\n");
exit(1);
}
if (list) {
exit(0);
}
else {
fprintf(stderr, "Extended device %s not found\n", argv[1]);
exit(1);
}
}
Status
XmuLookupStandardColormap(Display *dpy, int screen, VisualID visualid,
unsigned int depth, Atom property,
Bool replace, Bool retain)
/*
* dpy - specifies X server connection
* screen - specifies screen of display
* visualid - specifies the visual type
* depth - specifies the visual type
* property - a standard colormap property
* replace - specifies whether to replace
* retain - specifies whether to retain
*/
{
Display *odpy; /* original display connection */
XStandardColormap *colormap;
XVisualInfo vinfo_template, *vinfo; /* visual */
long vinfo_mask;
unsigned long r_max, g_max, b_max; /* allocation */
int count;
Colormap cmap; /* colormap ID */
Status status = 0;
/* Match the requested visual */
vinfo_template.visualid = visualid;
vinfo_template.screen = screen;
vinfo_template.depth = depth;
vinfo_mask = VisualIDMask | VisualScreenMask | VisualDepthMask;
if ((vinfo = XGetVisualInfo(dpy, vinfo_mask, &vinfo_template, &count)) ==
NULL)
return 0;
/* Monochrome visuals have no standard maps */
if (vinfo->colormap_size <= 2) {
XFree((char *) vinfo);
return 0;
}
/* If the requested property already exists on this screen, and,
* if the replace flag has not been set to true, return success.
* lookup() will remove a pre-existing map if replace is true.
*/
if (lookup(dpy, screen, visualid, property, (XStandardColormap *) NULL,
replace) && !replace) {
XFree((char *) vinfo);
return 1;
}
/* Determine the best allocation for this property under the requested
* visualid and depth, and determine whether or not to use the default
* colormap of the screen.
*/
if (!XmuGetColormapAllocation(vinfo, property, &r_max, &g_max, &b_max)) {
XFree((char *) vinfo);
return 0;
}
cmap = (property == XA_RGB_DEFAULT_MAP &&
visualid == XVisualIDFromVisual(DefaultVisual(dpy, screen)))
? DefaultColormap(dpy, screen) : None;
/* If retaining resources, open a new connection to the same server */
if (retain) {
odpy = dpy;
if ((dpy = XOpenDisplay(XDisplayString(odpy))) == NULL) {
XFree((char *) vinfo);
return 0;
}
}
/* Create the standard colormap */
colormap = XmuStandardColormap(dpy, screen, visualid, depth, property,
cmap, r_max, g_max, b_max);
/* Set the standard colormap property */
if (colormap) {
XGrabServer(dpy);
if (lookup(dpy, screen, visualid, property, colormap, replace) &&
!replace) {
/* Someone has defined the property since we last looked.
* Since we will not replace it, release our own resources.
* If this is the default map, our allocations will be freed
* when this connection closes.
*/
if (colormap->killid == ReleaseByFreeingColormap)
XFreeColormap(dpy, colormap->colormap);
}
else if (retain) {
XSetCloseDownMode(dpy, RetainPermanent);
}
XUngrabServer(dpy);
XFree((char *) colormap);
status = 1;
}
if (retain)
XCloseDisplay(dpy);
XFree((char *) vinfo);
return status;
}
extern "C" KDE_EXPORT int kdemain(int argc, char **argv)
{
{
QCString multiHead = getenv("KDE_MULTIHEAD");
if(multiHead.lower() == "true")
{
Display *dpy = XOpenDisplay(NULL);
if(!dpy)
{
fprintf(stderr, "%s: FATAL ERROR: couldn't open display %s\n", argv[0], XDisplayName(NULL));
exit(1);
}
int number_of_screens = ScreenCount(dpy);
kicker_screen_number = DefaultScreen(dpy);
int pos;
QCString display_name = XDisplayString(dpy);
XCloseDisplay(dpy);
dpy = 0;
if((pos = display_name.findRev('.')) != -1)
display_name.remove(pos, 10);
QCString env;
if(number_of_screens != 1)
{
for(int i = 0; i < number_of_screens; i++)
{
if(i != kicker_screen_number && fork() == 0)
{
kicker_screen_number = i;
// break here because we are the child process, we don't
// want to fork() anymore
break;
}
}
env.sprintf("DISPLAY=%s.%d", display_name.data(), kicker_screen_number);
if(putenv(strdup(env.data())))
{
fprintf(stderr, "%s: WARNING: unable to set DISPLAY environment variable\n", argv[0]);
perror("putenv()");
}
}
}
}
KGlobal::locale()->setMainCatalogue("kicker");
QCString appname;
if(kicker_screen_number == 0)
appname = "kicker";
else
appname.sprintf("kicker-screen-%d", kicker_screen_number);
KAboutData aboutData(appname.data(), I18N_NOOP("KDE Panel"), version, description, KAboutData::License_BSD,
I18N_NOOP("(c) 1999-2004, The KDE Team"));
aboutData.addAuthor("Aaron J. Seigo", I18N_NOOP("Current maintainer"), "*****@*****.**");
aboutData.addAuthor("Matthias Elter", 0, "*****@*****.**");
aboutData.addAuthor("Matthias Ettrich", 0, "*****@*****.**");
aboutData.addAuthor("Wilco Greven", 0, "*****@*****.**");
aboutData.addAuthor("Rik Hemsley", 0, "*****@*****.**");
aboutData.addAuthor("Daniel M. Duley", 0, "*****@*****.**");
aboutData.addAuthor("Preston Brown", 0, "*****@*****.**");
aboutData.addAuthor("John Firebaugh", 0, "*****@*****.**");
aboutData.addAuthor("Waldo Bastian", I18N_NOOP("Kiosk mode"), "*****@*****.**");
aboutData.addCredit("Jessica Hall", /* I18N_NOOP("KConfigXT") */ 0, "*****@*****.**");
aboutData.addCredit("Stefan Nikolaus", /* I18N_NOOP("Bug fixes") */ 0, "*****@*****.**");
aboutData.addCredit("Benoît Minisini", /* I18N_NOOP("Bug fixes") */ 0, "*****@*****.**");
KCmdLineArgs::init(argc, argv, &aboutData);
if(!Kicker::start())
{
kdError() << "kicker is already running!" << endl;
return 0;
}
if(signal(SIGTERM, sighandler) == SIG_IGN)
signal(SIGTERM, SIG_IGN);
if(signal(SIGINT, sighandler) == SIG_IGN)
signal(SIGINT, SIG_IGN);
if(signal(SIGHUP, sighandler) == SIG_IGN)
signal(SIGHUP, SIG_IGN);
// send it even before KApplication ctor, because ksmserver will launch another app as soon
// as QApplication registers with it
DCOPClient *cl = new DCOPClient;
cl->attach();
DCOPRef r("ksmserver", "ksmserver");
r.setDCOPClient(cl);
r.send("suspendStartup", QCString("kicker"));
delete cl;
Kicker *kicker = new Kicker;
int rv = kicker->exec();
delete kicker;
return rv;
}
/********************************************************************
*
* Setup a child service record per the selection request.
*/
void mgr_initialize( XEvent *report, XpPdmServiceRec *rec )
{
Display *testdpy;
char buf[1024];
Display *selection_display;
Window requestor;
Atom prop_atom;
unsigned long tafter;
XTextProperty text_prop;
char **list;
int list_cnt;
/*
* Grab the PDM_CLIENT_PROP from which all the juicy
* information is retrieved.
*/
selection_display = report->xselectionrequest.display;
requestor = report->xselectionrequest.requestor;
prop_atom = report->xselectionrequest.property;
if ( XGetWindowProperty( selection_display, requestor, prop_atom,
0, 100000, True, AnyPropertyType,
&text_prop.encoding,
&text_prop.format,
&text_prop.nitems,
&tafter,
&text_prop.value ) != Success ) {
/*
* Error
*/
rec->pdm_exec_errorcode = g.pdm_start_error;
sprintf( buf, PDMD_MSG_5, g.prog_name );
rec->pdm_exec_errormessage = xpstrdup( buf );
return;
}
if ( text_prop.format != 8 ) {
/*
* Error
*/
rec->pdm_exec_errorcode = g.pdm_start_error;
sprintf( buf, PDMD_MSG_6, g.prog_name );
rec->pdm_exec_errormessage = xpstrdup( buf );
return;
}
if ( XmbTextPropertyToTextList( selection_display, &text_prop,
&list, &list_cnt ) < 0 ) {
/*
* Error
*/
rec->pdm_exec_errorcode = g.pdm_start_error;
sprintf( buf, PDMD_MSG_7, g.prog_name );
rec->pdm_exec_errormessage = xpstrdup( buf );
return;
}
/*
* Fill in the PDM_MANAGER portion of the client record.
*/
rec->video_display_str = xpstrdup( list[0] );
rec->video_window = strtol(list[1], (char **)NULL, 16);
rec->print_display_str = xpstrdup( list[2] );
rec->print_window = strtol(list[3], (char **)NULL, 16);
#if 0 && defined(PRINTING_SUPPORTED)
rec->print_context = strtol(list[4], (char **)NULL, 16);
#endif /* PRINTING_SUPPORTED */
rec->locale_hint = xpstrdup( list[5] );
XFreeStringList( list );
rec->selection_display = selection_display;
rec->requestor = requestor;
rec->prop_atom = prop_atom;
rec->selection = report->xselectionrequest.selection;
rec->time = report->xselectionrequest.time;
rec->mgr_flag = True; /* mgr portion of rec now valid */
/*
* Optimization. The only live display connection, for which we
* need to trap XIO errors, is "selection display". For the
* "video" and "print" displays, we have the display strings and
* can establish connections as we need them. Since they are rarely
* used, and opening them up here would create XIO liability problems
* and a startup performance hit, we won't establish connections now.
*
* One optimization however is to see if the "print" display would
* just happen to be the same at the "selection display" currently
* open.
*/
if ( !strcmp( XDisplayString(rec->selection_display),
rec->print_display_str ) ) {
rec->seldpy_as_printdpy = True;
}
else {
rec->seldpy_as_printdpy = False;
#ifdef OPTIONAL_PXAUTH_PRETEST
/*
* Verify connectability to the Print Server.
*
* Note: once beyond the selection phase, all communication
* will be by way of the Print Server. If we cannot
* connect later, then we will have no way to deliver
* EXIT_PXAUTH, EXIT_VXAUTH, EXIT_ERROR, EXIT_OK or
* EXIT_CANCEL. Real bad news!
*
* It is better to discover now that we don't have
* connection authorization for the print display since
* we can still let the user know of PXAUTH problems
* via the selection display currently open.
*
* Unfortunately, this pre-test is a performance hit in the
* startup phase.
*/
if ( ! (testdpy = XOpenDisplay(rec->print_display_str)) ) {
rec->pdm_exec_errorcode = g.pdm_start_pxauth;
return;
}
XCloseDisplay( testdpy );
#endif /* OPTIONAL_PXAUTH_PRETEST */
}
#ifdef OPTIONAL_VXAUTH_PRETEST
/*
* Verify connectability to the Video Server.
*
* It is better to discover now that we don't have
* connection authorization for the video display since
* we can still let the user know of VXAUTH problems
* via the selection display currently open.
*
* Unfortunately, this pre-test is a performance hit in the
* startup phase.
*/
if ( ! (testdpy = XOpenDisplay(rec->video_display_str)) ) {
rec->pdm_exec_errorcode = g.pdm_start_vxauth;
return;
}
XCloseDisplay( testdpy );
#endif /* OPTIONAL_VXAUTH_PRETEST */
}
static
void *XpuPrintToFile( Display *pdpy, XPContext pcontext, const char *filename )
{
MyPrintFileData *mpfd;
if( (mpfd = (MyPrintFileData *)malloc(sizeof(MyPrintFileData))) == NULL )
return(NULL);
/* create pipe */
if( pipe(mpfd->pipe) == -1 )
{
/* this should never happen, but... */
perror("XpuPrintToFile: cannot create pipe");
free(mpfd);
return(NULL);
}
mpfd->parent_pdpy = pdpy;
mpfd->displayname = XDisplayString(pdpy);
mpfd->pcontext = pcontext;
mpfd->file_name = filename;
mpfd->file = NULL;
mpfd->status = XPGetDocError;
/* make sure we can open the file for writing */
if( (mpfd->file = fopen(mpfd->file_name, "w")) == NULL )
{
/* fopen() error */
close(mpfd->pipe[1]);
close(mpfd->pipe[0]);
free(mpfd);
return(NULL);
}
/* its important to flush before we fork, to make sure that the
* XpStartJob gets through first in the parent
*/
XFlush(pdpy);
mpfd->pid = fork();
if( mpfd->pid == 0 )
{
/* we're now in the fork()'ed child */
PrintToFile_Consumer(mpfd);
}
else if( mpfd->pid < 0 )
{
/* fork() error */
close(mpfd->pipe[1]);
close(mpfd->pipe[0]);
fclose(mpfd->file);
free(mpfd);
return(NULL);
}
/* we're still in the parent */
XPU_DEBUG_ONLY(printf("### parent fork()'ed consumer child.\n"));
/* child will write into file - we don't need it anymore here... :-) */
fclose(mpfd->file);
close(mpfd->pipe[1]);
return(mpfd);
}
extern struct gl_platform *gl_platform_create(gs_device_t *device,
const struct gs_init_data *info)
{
/* There's some trickery here... we're mixing libX11, xcb, and GLX
For an explanation see here: http://xcb.freedesktop.org/MixingCalls/
Essentially, GLX requires Xlib. Everything else we use xcb. */
struct gl_windowinfo *wi = gl_windowinfo_create(info);
struct gl_platform * plat = bmalloc(sizeof(struct gl_platform));
Display * display;
print_info_stuff(info);
if (!wi) {
blog(LOG_ERROR, "Failed to create window info!");
goto fail_wi_create;
}
display = XOpenDisplay(XDisplayString(info->window.display));
if (!display) {
blog(LOG_ERROR, "Unable to open new X connection!");
goto fail_display_open;
}
XSetEventQueueOwner(display, XCBOwnsEventQueue);
XSetErrorHandler(x_error_handler);
/* We assume later that cur_swap is already set. */
device->cur_swap = &plat->swap;
device->plat = plat;
plat->display = display;
plat->swap.device = device;
plat->swap.info = *info;
plat->swap.wi = wi;
if (!gl_platform_init_swapchain(&plat->swap)) {
blog(LOG_ERROR, "Failed to initialize swap chain!");
goto fail_init_swapchain;
}
if (!gl_context_create(plat)) {
blog(LOG_ERROR, "Failed to create context!");
goto fail_context_create;
}
if (!glXMakeCurrent(plat->display, wi->window, plat->context)) {
blog(LOG_ERROR, "Failed to make context current.");
goto fail_make_current;
}
if (!gladLoadGL()) {
blog(LOG_ERROR, "Failed to load OpenGL entry functions.");
goto fail_load_gl;
}
blog(LOG_INFO, "OpenGL version: %s\n", glGetString(GL_VERSION));
goto success;
fail_make_current:
gl_context_destroy(plat);
fail_context_create:
fail_load_gl:
fail_init_swapchain:
XCloseDisplay(display);
fail_display_open:
fail_wi_create:
gl_windowinfo_destroy(wi);
free(plat);
plat = NULL;
success:
return plat;
}
