//---------------------------------------------------------------------------
// GLX init
//---------------------------------------------------------------------------
bool Pipe::configInit()
{
const std::string displayName = getXDisplayString();
const char* cDisplayName = ( displayName.empty() ?
0 : displayName.c_str( ));
Display* xDisplay = XOpenDisplay( cDisplayName );
if( !xDisplay )
{
setError( ERROR_GLXPIPE_DEVICE_NOTFOUND );
LBWARN << getError() << " " << XDisplayName( displayName.c_str( ))
<< ": " << lunchbox::sysError << std::endl;
return false;
}
int major, event, error;
if( !XQueryExtension( xDisplay, "GLX", &major, &event, &error ))
{
setError( ERROR_GLXPIPE_GLX_NOTFOUND );
XCloseDisplay( xDisplay );
return false;
}
setXDisplay( xDisplay );
LBVERB << "Opened X display " << XDisplayName( displayName.c_str( )) << " @"
<< xDisplay << ", device " << getPipe()->getDevice() << std::endl;
return _configInitGLXEW();
}
static int DGA_Available(void)
{
const char *display;
Display *dpy;
int available;
/* The driver is available is available if the display is local
and the DGA 2.0+ extension is available, and we can map mem.
*/
available = 0;
display = NULL;
if ( (strncmp(XDisplayName(display), ":", 1) == 0) ||
(strncmp(XDisplayName(display), "unix:", 5) == 0) ) {
dpy = XOpenDisplay(display);
if ( dpy ) {
int events, errors, major, minor;
if ( SDL_NAME(XDGAQueryExtension)(dpy, &events, &errors) &&
SDL_NAME(XDGAQueryVersion)(dpy, &major, &minor) ) {
int screen;
screen = DefaultScreen(dpy);
if ( (major >= 2) &&
SDL_NAME(XDGAOpenFramebuffer)(dpy, screen) ) {
available = 1;
SDL_NAME(XDGACloseFramebuffer)(dpy, screen);
}
}
XCloseDisplay(dpy);
}
}
return(available);
}
QByteArray UINVControl::GetNVEDID(Display *XDisplay, int Screen)
{
if (!NVControlAvailable(XDisplay))
return QByteArray();
QMutexLocker locker(gNVCtrlLock);
QByteArray result;
if (!XNVCTRLIsNvScreen(XDisplay, Screen))
{
LOG(VB_GENERAL, LOG_ERR, QString("NV-CONTROL is not available on screen %1 of display '%2'")
.arg(Screen).arg(XDisplayName(NULL)));
return result;
}
int displays = 0;
Bool ok = XNVCTRLQueryAttribute(XDisplay, Screen, 0, NV_CTRL_CONNECTED_DISPLAYS, &displays);
if (ok != True)
{
LOG(VB_GENERAL, LOG_ERR, "Failed to retrieve display list");
return result;
}
int displaycount = ListDisplays(displays);
if (displaycount != 1)
{
LOG(VB_GENERAL, LOG_WARNING, "There is more than one physical display attached to this screen. Ignoring EDID");
return result;
}
int edid = NV_CTRL_EDID_AVAILABLE_FALSE;
ok = XNVCTRLQueryAttribute(XDisplay, Screen, displays, NV_CTRL_EDID_AVAILABLE, &edid);
if (ok != True)
{
LOG(VB_GENERAL, LOG_INFO, "Failed to check EDID_AVAILABLE attribute");
return result;
}
if (edid != NV_CTRL_EDID_AVAILABLE_TRUE)
{
LOG(VB_GENERAL, LOG_INFO, "EDID not available");
return result;
}
unsigned char* data = NULL;
int datalength = 0;
ok = XNVCTRLQueryBinaryData(XDisplay, Screen, displays, NV_CTRL_BINARY_DATA_EDID, &data, &datalength);
if (ok != True)
{
LOG(VB_GENERAL, LOG_INFO, QString("EDID not available on screen %1 of display '%2'")
.arg(Screen).arg(XDisplayName(NULL)));
return result;
}
result = QByteArray((const char*)data, datalength);
delete data;
return result;
}
static SDL_bool have_mitshm(void)
{
/* Only use shared memory on local X servers */
if ( (SDL_strncmp(XDisplayName(NULL), ":", 1) == 0) ||
(SDL_strncmp(XDisplayName(NULL), "unix:", 5) == 0) ) {
return SDL_X11_HAVE_SHM;
}
return SDL_FALSE;
}
Display *xwin_init(const char *display_name, const char *prgname, const char *classname, int argc, char **argv, int *pscreen, unsigned int *pw, unsigned int *ph)
{
XWindowAttributes xwa;
/*
FILE *f;
f = fopen("bee.raw", "rb");
fread(leftarrow_bits, 1, 32, f);
fclose(f);
f = fopen("beemask.raw", "rb");
fread(rightarrow_bits, 1, 32, f);
fclose(f);
frickelfix(leftarrow_bits);
frickelfix(rightarrow_bits);
*/
if ((_wndh_gl.display = XOpenDisplay(display_name)) == NULL)
{
fprintf(stderr, "failed to connect to X server %s\n", XDisplayName(display_name));
exit (EXIT_FAILURE);
}
XSynchronize(_wndh_gl.display, True);
_wndh_gl.default_screen = DefaultScreen(_wndh_gl.display);
_wndh_gl.width = DisplayWidth(_wndh_gl.display, _wndh_gl.default_screen);
_wndh_gl.height = DisplayHeight(_wndh_gl.display, _wndh_gl.default_screen);
_wndh_gl.black = BlackPixel(_wndh_gl.display, _wndh_gl.default_screen);
_wndh_gl.white = WhitePixel(_wndh_gl.display, _wndh_gl.default_screen);
_wndh_gl.root_window = RootWindow(_wndh_gl.display, _wndh_gl.default_screen);
XGetWindowAttributes(_wndh_gl.display, _wndh_gl.root_window, &xwa);
_wndh_gl.depth = xwa.depth;
_wndh_gl.uparr_pix = XCreatePixmapFromBitmapData(_wndh_gl.display, _wndh_gl.root_window,
uparrow_bits, uparrow_width, uparrow_height, _wndh_gl.black, _wndh_gl.white, _wndh_gl.depth);
_wndh_gl.dnarr_pix = XCreatePixmapFromBitmapData(_wndh_gl.display, _wndh_gl.root_window,
downarrow_bits, downarrow_width, downarrow_height, _wndh_gl.black, _wndh_gl.white, _wndh_gl.depth);
_wndh_gl.lfarr_pix = XCreatePixmapFromBitmapData(_wndh_gl.display, _wndh_gl.root_window,
leftarrow_bits, leftarrow_width, leftarrow_height, _wndh_gl.black, _wndh_gl.white, _wndh_gl.depth);
_wndh_gl.rtarr_pix = XCreatePixmapFromBitmapData(_wndh_gl.display, _wndh_gl.root_window,
rightarrow_bits, rightarrow_width, rightarrow_height, _wndh_gl.black, _wndh_gl.white, _wndh_gl.depth);
_wndh_gl.sizer_pix = XCreatePixmapFromBitmapData(_wndh_gl.display, _wndh_gl.root_window,
sizer_bits, sizer_width, sizer_height, _wndh_gl.black, _wndh_gl.white, _wndh_gl.depth);
_wndh_gl.wm_del_atom = XInternAtom(_wndh_gl.display, "WM_DELETE_WINDOW", True);
strncpy(_wndh_gl.prgname, prgname, WH_MAX_NAMELENGTH);
strncpy(_wndh_gl.classname, classname, WH_MAX_NAMELENGTH);
_wndh_gl.argc = argc;
_wndh_gl.argv = argv;
*pscreen = _wndh_gl.default_screen;
*pw = _wndh_gl.width;
*ph = _wndh_gl.height;
#ifdef DEBUG
printf("connected to X server %s\n", XDisplayName(display_name));
#endif
return (_wndh_gl.display);
}
int
main(void)
{
Display *dpy;
Window root;
size_t i, x, ret, len;
if (!(dpy = XOpenDisplay(NULL)))
die("Couldn't open display '%s'\n", XDisplayName(NULL));
root = DefaultRootWindow(dpy);
len = sizeof(sfuncs) / sizeof(sfuncs[0]);
for (;;) {
memset(ststr, '\0', STATUSSZ);
for (i = 0, x = 0; i < len; i++, x += ret)
ret = (*sfuncs[i])(&(ststr[x]), STATUSSZ - x);
XStoreName(dpy, root, ststr);
XSync(dpy, False);
sleep(delay);
}
XCloseDisplay(dpy);
return 0;
}
/******************************************************************************
StartMeUp - Do X initialization things
******************************************************************************/
void StartMeUp()
{
if (!(dpy = XOpenDisplay("")))
{
fprintf(stderr,"%s: can't open display %s", Module,
XDisplayName(""));
exit (1);
}
x_fd = XConnectionNumber(dpy);
screen= DefaultScreen(dpy);
Root = RootWindow(dpy, screen);
d_depth = DefaultDepth(dpy, screen);
ScreenHeight = DisplayHeight(dpy,screen);
ScreenWidth = DisplayWidth(dpy,screen);
if ((ButtonFont=XLoadQueryFont(dpy,font_string))==NULL)
{
if ((ButtonFont=XLoadQueryFont(dpy,"fixed"))==NULL) exit(1);
}
fontheight = ButtonFont->ascent+ButtonFont->descent;
win_width=XTextWidth(ButtonFont,"XXXXXXXXXXXXXXX",10);
}
int main(int argc, char **argv)
{
Display *d;
struct timespec interval;
interval.tv_sec = 0;
interval.tv_nsec = 100000000;
if(!(d = XOpenDisplay(NULL))) {
fprintf(stderr, "\"%s\" can't open.\n", XDisplayName(NULL));
exit(EXIT_FAILURE);
}
int ignore;
if(!(XQueryExtension(d, "XTEST", &ignore, &ignore, &ignore))) {
fprintf(stderr, "\"XTEST\" extension disabled.\n");
exit(EXIT_FAILURE);
}
while(1){
XTestFakeButtonEvent(d, RMB, True, 0);
XTestFakeButtonEvent(d, RMB, False, 0);
nanosleep(&interval, NULL);
XSync(d, False);
}
XCloseDisplay(d);
exit(EXIT_SUCCESS);
}
void
init(void) {
load("libEGL.so.1");
display = XOpenDisplay(NULL);
if (!display) {
std::cerr << "error: unable to open display " << XDisplayName(NULL) << "\n";
exit(1);
}
screen = DefaultScreen(display);
eglDisplay = eglGetDisplay((EGLNativeDisplayType)display);
if (eglDisplay == EGL_NO_DISPLAY) {
std::cerr << "error: unable to get EGL display\n";
XCloseDisplay(display);
exit(1);
}
EGLint major, minor;
if (!eglInitialize(eglDisplay, &major, &minor)) {
std::cerr << "error: unable to initialize EGL display\n";
XCloseDisplay(display);
exit(1);
}
}
int
main(int argc, char **argv)
{
Display *dpy;
Atom *atom;
int i,natoms;
/* connect to X server */
if ((dpy=XOpenDisplay(NULL))==NULL) {
fprintf(stderr,"Cannot connect to display %s\n",
XDisplayName(NULL));
exit(-1);
}
/* list properties of root window */
atom = XListProperties(dpy,DefaultRootWindow(dpy),&natoms);
printf("Number of properties = %d\n",natoms);
for (i=0; i<natoms; i++)
printf("property[%d] = %s\n",i,XGetAtomName(dpy,atom[i]));
/* close connection to X server */
XCloseDisplay(dpy);
return EXIT_SUCCESS;
}
static int x11IOErrorHandler(Display *dpy)
{
const char * dpyName = XDisplayName(NULL);
const char * errnoStr = strerror(errno);
char threadName[80];
int shallBeDetached = 0;
JNIEnv *jniEnv = NativewindowCommon_GetJNIEnv(jvmHandle, jvmVersion, &shallBeDetached);
(void) NativewindowCommon_GetStaticStringMethod(jniEnv, X11UtilClazz, getCurrentThreadNameID, threadName, sizeof(threadName), "n/a");
fprintf(stderr, "Nativewindow X11 IOError (Thread %s): Display %p (%s): %s\n", threadName, dpy, dpyName, errnoStr);
(*jniEnv)->CallStaticVoidMethod(jniEnv, X11UtilClazz, dumpStackID);
if (NULL != jniEnv) {
NativewindowCommon_FatalError(jniEnv, "Nativewindow X11 IOError (Thread %s): Display %p (%s): %s", threadName, dpy, dpyName, errnoStr);
if (shallBeDetached) {
(*jvmHandle)->DetachCurrentThread(jvmHandle);
}
}
if(NULL!=origIOErrorHandler) {
origIOErrorHandler(dpy);
}
return 0;
}
static Display *disp(void) {
if(!disp_var) {
disp_var = XOpenDisplay(0);
if(!disp_var) errx(1, "cannot open X display %s", XDisplayName(0));
}
return(disp_var);
}
int pg_win_rename(char *name) {
int screen, pgwinids[N_PGWINS], npgwins;
char *display_name=NULL;
Window pgwins[N_PGWINS];
/* Connect to X server */
if ((dpy = XOpenDisplay(display_name)) == NULL ) {
nferrormsg("cpgwinrename(): Couldn't connect to X server %s!",
XDisplayName(display_name));
return 0;
}
screen = DefaultScreen(dpy);
npgwins = 0;
if (!pg_get_wins(RootWindow(dpy, screen), pgwins, pgwinids, &npgwins)) {
nferrormsg("cpgwinrename(): Couldn't get PGPLOT window IDs!");
return 0;
} else if (npgwins > N_PGWINS) {
nferrormsg("cpgwinrename(): Too many PGPLOT windows!");
return 0;
}
/* Rename */
if (npgwins)
XStoreName(dpy, pgwins[idxival(pgwinids, npgwins,
ijmax(pgwinids, npgwins))], name);
/* Disconnect from X server */
XCloseDisplay(dpy);
return 1;
}
void aX_open_second_disp(char *display_name,
aX_default_resources *defres)
{
char *disp_res;
XrmDatabase serverDB;
if((defres->disp = XOpenDisplay(display_name)) == NULL) {
fprintf(stderr,
"%s: aX_open_second_disp: cannot connect to X server %s\n",
prog_name, XDisplayName(display_name));
exit(-1);
}
disp_res = XResourceManagerString(defres->disp);
if(disp_res) serverDB = XrmGetStringDatabase(disp_res);
else serverDB = NULL;
XrmMergeDatabases(serverDB, &rDB);
get_def_res(defres);
add_disp(defres);
}
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 init_key(void)
{
if(!(dpy = XOpenDisplay(NULL)))
{
fprintf(stderr, "error: can not open display %s", XDisplayName(NULL));
exit(1);
}
screen = DefaultScreen(dpy);
root = RootWindow(dpy, screen);
opt_key = conf_get_key();
modmask = conf_get_mod();
int i, j;
XModifierKeymap *modmap = XGetModifierMapping(dpy);
for(i = 0; i < 8; i++)
{
for(j = 0; j < modmap->max_keypermod; j++)
{
if(modmap->modifiermap[i * modmap->max_keypermod + j] == XKeysymToKeycode(dpy, XK_Num_Lock))
numlockmask = (1 << i);
}
}
XFreeModifiermap(modmap);
}
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);
}
/*
* Pøipojit k serveru, zjistit o nìm informace
*/
static void open_display(void)
{
display_name = XDisplayName(NULL);
if(!(display = XOpenDisplay(display_name))) {
fprintf(stderr, "Cannot connect to X server \"%s\"\n", display_name);
exit(1);
}
debug("Connected to X server \"%s\"\n", display_name);
screen_num = DefaultScreen(display);
screen = DefaultScreenOfDisplay(display);
debug("Default screen number is %d\n", screen_num);
screen_width = DisplayWidth(display, screen_num);
screen_height = DisplayHeight(display, screen_num);
screen_width_mm = DisplayWidthMM(display, screen_num);
screen_height_mm = DisplayHeightMM(display, screen_num);
debug("Screen size is %ux%u pixels, %ux%u mm\n", screen_width,
screen_height, screen_width_mm, screen_height_mm);
root = RootWindow(display, screen_num);
black = BlackPixel(display, screen_num);
white = WhitePixel(display, screen_num);
debug("Root window ID is %#lx, black is %#lx, white is %#lx\n", root,
black, white);
def_gc = DefaultGC(display, screen_num);
if(!(def_font = XQueryFont(display, XGContextFromGC(def_gc)))) {
fprintf(stderr, "XQueryFont() failed\n");
exit(1);
}
}
/*
* Pøipojit k serveru, zjistit o nìm informace
*/
static void open_display(void)
{
display_name = XDisplayName(NULL);
if(!(display = XOpenDisplay(display_name))) {
fprintf(stderr, "Cannot connect to X server \"%s\"\n", display_name);
exit(1);
}
debug("Connected to X server \"%s\"\n", display_name);
screen_num = DefaultScreen(display);
screen = DefaultScreenOfDisplay(display);
debug("Default screen number is %d\n", screen_num);
screen_width = DisplayWidth(display, screen_num);
screen_height = DisplayHeight(display, screen_num);
screen_width_mm = DisplayWidthMM(display, screen_num);
screen_height_mm = DisplayHeightMM(display, screen_num);
debug("Screen size is %ux%u pixels, %ux%u mm\n", screen_width,
screen_height, screen_width_mm, screen_height_mm);
root = RootWindow(display, screen_num);
black = BlackPixel(display, screen_num);
white = WhitePixel(display, screen_num);
debug("Root window ID is %#lx, black is %#lx, white is %#lx\n", root,
black, white);
def_gc = DefaultGC(display, screen_num);
/* Toto volání XQueryFont() do def_font->fid neulo¾í ID fontu, ale
* grafického kontextu! Nevím, jak získat ID nebo jméno standardního
* fontu. */
if(!(def_font = XQueryFont(display, XGContextFromGC(def_gc)))) {
fprintf(stderr, "XQueryFont() failed\n");
exit(1);
}
}
void setup_environ(int scr)
{
char *tmp, *ptr;
char *display;
int tmp_len;
display=XDisplayName(wglobal.display);
tmp_len = strlen(display)+16;
tmp=ALLOC_N(char, tmp_len);
if(tmp==NULL){
warn_err();
return;
}
snprintf(tmp, tmp_len, "DISPLAY=%s", display);
ptr=strchr(tmp, ':');
if(ptr!=NULL){
ptr=strchr(ptr, '.');
if(ptr!=NULL)
*ptr='\0';
}
if(scr>=0){
int curr_len=strlen(tmp);
snprintf(tmp+curr_len, tmp_len-curr_len, ".%i", scr);
}
putenv(tmp);
/*XFree(display);*/
}
void open_display(char *display_name)
{
if ((display = XOpenDisplay(display_name)) == NULL) {
fprintf(stderr, "%s: Can't open display '%s'\n",
cmnd, XDisplayName(display_name));
exit(2);
}
}
void fl_open_display() {
fl_display = XOpenDisplay(dname);
if (!fl_display) {
fprintf(stderr,"Can't open display: %s\n",XDisplayName(dname));
exit(1);
}
fl_screen = DefaultScreen(fl_display);
}
void
meta_ui_init (int *argc, char ***argv)
{
if (!gtk_init_check (argc, argv))
meta_fatal ("Unable to open X display %s\n", XDisplayName (NULL));
meta_stock_icons_init ();
}
boolean xf_pre_connect(freerdp* instance)
{
xfInfo* xfi;
rdpSettings* settings;
xfi = (xfInfo*) xzalloc(sizeof(xfInfo));
SET_XFI(instance, xfi);
xfi->instance = instance;
settings = instance->settings;
settings->order_support[NEG_DSTBLT_INDEX] = True;
settings->order_support[NEG_PATBLT_INDEX] = True;
settings->order_support[NEG_SCRBLT_INDEX] = True;
settings->order_support[NEG_OPAQUE_RECT_INDEX] = True;
settings->order_support[NEG_DRAWNINEGRID_INDEX] = False;
settings->order_support[NEG_MULTIDSTBLT_INDEX] = False;
settings->order_support[NEG_MULTIPATBLT_INDEX] = False;
settings->order_support[NEG_MULTISCRBLT_INDEX] = False;
settings->order_support[NEG_MULTIOPAQUERECT_INDEX] = True;
settings->order_support[NEG_MULTI_DRAWNINEGRID_INDEX] = False;
settings->order_support[NEG_LINETO_INDEX] = True;
settings->order_support[NEG_POLYLINE_INDEX] = True;
settings->order_support[NEG_MEMBLT_INDEX] = True;
settings->order_support[NEG_MEM3BLT_INDEX] = False;
settings->order_support[NEG_SAVEBITMAP_INDEX] = True;
settings->order_support[NEG_GLYPH_INDEX_INDEX] = True;
settings->order_support[NEG_FAST_INDEX_INDEX] = True;
settings->order_support[NEG_FAST_GLYPH_INDEX] = True;
settings->order_support[NEG_POLYGON_SC_INDEX] = False;
settings->order_support[NEG_POLYGON_CB_INDEX] = False;
settings->order_support[NEG_ELLIPSE_SC_INDEX] = False;
settings->order_support[NEG_ELLIPSE_CB_INDEX] = False;
freerdp_chanman_pre_connect(GET_CHANMAN(instance), instance);
xfi->display = XOpenDisplay(NULL);
if (xfi->display == NULL)
{
printf("xf_pre_connect: failed to open display: %s\n", XDisplayName(NULL));
return False;
}
xf_kbd_init(xfi);
xfi->xfds = ConnectionNumber(xfi->display);
xfi->screen_number = DefaultScreen(xfi->display);
xfi->screen = ScreenOfDisplay(xfi->display, xfi->screen_number);
xfi->depth = DefaultDepthOfScreen(xfi->screen);
xfi->big_endian = (ImageByteOrder(xfi->display) == MSBFirst);
xfi->decoration = True;
xfi->mouse_motion = True;
return True;
}
// ######################################################################
AutomateXWin::AutomateXWin(const char* win_name) :
itsDisplay(NULL),
itsScreen(0),
itsImage(NULL),
itsWidth(0),
itsHeight(0),
itsDepth(0)
{
char *dispName = XDisplayName(NULL);
unsigned num_tries;
int event_base, error_base;
int major_version, minor_version;
itsDisplay = XOpenDisplay(dispName);
if(!itsDisplay)
LFATAL("XOpenDisplay(%s) failed\n", dispName);
if (!XTestQueryExtension (itsDisplay, &event_base, &error_base, &major_version, &minor_version)) {
XCloseDisplay(itsDisplay);
LFATAL("XTest extension not supported on server");
}
LINFO("XTestQueryExtension passed.");
LINFO("XTest information for server \"%s\":", DisplayString(itsDisplay));
LINFO(" Major version: %d", major_version);
LINFO(" Minor version: %d", minor_version);
LINFO(" First event number: %d", event_base);
LINFO(" First error number: %d", error_base);
itsScreen = DefaultScreen(itsDisplay);
itsRootWin = RootWindow(itsDisplay, itsScreen);
for(num_tries=0;;)
{
itsWindow = XWindowByName(itsDisplay, itsRootWin, win_name);
if(itsWindow) break;
if(++num_tries == 100)
LFATAL("XWindowByName\n");
usleep(20000);
}
XFlush(itsDisplay);
XSync(itsDisplay, False);
#ifdef USE_SHM
if(!XShmQueryExtension(itsDisplay))
LFATAL("XShmQueryExtension");
#endif
GetWindowGeometry();
if(!XMatchVisualInfo(itsDisplay, itsScreen, itsDepth, DirectColor, &itsVInfo))
{
return;
}
}
bool
createGLXContextAndWindow(glx_state_t *state, const device_config_t& device_config)
{
int rgba_attribs[] = {
GLX_RGBA ,
GLX_RED_SIZE , 1,
GLX_GREEN_SIZE , 1,
GLX_BLUE_SIZE , 1,
GLX_ALPHA_SIZE , 1,
//GLX_STENCIL_SIZE , 8,
//GLX_DOUBLEBUFFER , True,
None
};
XVisualInfo *visinfo;
XSetWindowAttributes attrs;
state->dpy = XOpenDisplay (NULL);
if (!state->dpy) {
warnx ("Failed to open display: %s\n", XDisplayName (0));
return false;
}
visinfo = glXChooseVisual (state->dpy, DefaultScreen (state->dpy), rgba_attribs);
if (visinfo == NULL) {
warnx ("Failed to create RGBA and double-buffered visuals\n");
XCloseDisplay (state->dpy);
return NULL;
}
attrs.colormap = XCreateColormap (state->dpy,
RootWindow (state->dpy, visinfo->screen),
visinfo->visual, AllocNone);
attrs.border_pixel = 0;
state->window = XCreateWindow (state->dpy, DefaultRootWindow (state->dpy),
0, 0,
device_config.width, device_config.height,
0, // border width
visinfo->depth,
InputOutput, visinfo->visual,
CWBorderPixel | CWColormap | CWEventMask,
&attrs);
state->width = device_config.width;
state->height = device_config.height;
XMapWindow (state->dpy, state->window);
//state->gc = XCreateGC(state->dpy, state->window, 0, NULL);
state->glx_context = glXCreateContext (state->dpy, visinfo, NULL, True);
XFree (visinfo);
if (state->glx_context == NULL) {
warnx ("Could not create glx context\n");
XCloseDisplay (state->dpy);
return false;
}
return true;
}
static int x11IOErrorHandler(Display *dpy)
{
fprintf(stderr, "Nativewindow X11 IOError: Display %p (%s): %s\n", dpy, XDisplayName(NULL), strerror(errno));
// _FatalError(x11ErrorHandlerJNIEnv, "Nativewindow X11 IOError: Display %p (%s): %s", dpy, XDisplayName(NULL), strerror(errno));
if(NULL!=origIOErrorHandler) {
origIOErrorHandler(dpy);
}
return 0;
}
static cairo_surface_t *
_cairo_boilerplate_xlib_render_0_0_create_surface (const char *name,
cairo_content_t content,
double width,
double height,
double max_width,
double max_height,
cairo_boilerplate_mode_t mode,
void **closure)
{
xlib_target_closure_t *xtc;
Display *dpy;
int screen;
Pixmap pixmap;
cairo_surface_t *surface, *dummy;
*closure = xtc = xcalloc (1, sizeof (xlib_target_closure_t));
width = ceil (width);
if (width < 1)
width = 1;
height = ceil (height);
if (height < 1)
height = 1;
xtc->dpy = dpy = XOpenDisplay (NULL);
if (xtc->dpy == NULL) {
free (xtc);
CAIRO_BOILERPLATE_DEBUG (("Failed to open display: %s\n", XDisplayName(0)));
return NULL;
}
screen = DefaultScreen (dpy);
pixmap = XCreatePixmap (dpy, DefaultRootWindow (dpy), 1, 1,
DefaultDepth (dpy, screen));
dummy = cairo_xlib_surface_create (dpy, pixmap,
DefaultVisual (dpy, screen),
1, 1);
cairo_xlib_device_debug_cap_xrender_version (cairo_surface_get_device (dummy),
0, 0);
if (mode == CAIRO_BOILERPLATE_MODE_TEST)
surface = _cairo_boilerplate_xlib_test_create_surface (dpy, content, width, height, xtc);
else /* mode == CAIRO_BOILERPLATE_MODE_PERF */
surface = _cairo_boilerplate_xlib_perf_create_surface (dpy, content, width, height, xtc);
cairo_surface_destroy (dummy);
XFreePixmap (dpy, pixmap);
if (surface == NULL || cairo_surface_status (surface))
_cairo_boilerplate_xlib_cleanup (xtc);
return surface;
}
void initXWin(int argc, char **argv)
{
int pos;
XWMHints wmhints;
XSizeHints shints;
winsize=astep ? ASTEPSIZE : NORMSIZE;
if((d_display=XOpenDisplay(display))==NULL)
{
fprintf(stderr,"%s : Unable to open X display '%s'.\n", NAME, XDisplayName(display));
exit(1);
}
_XA_GNUSTEP_WM_FUNC=XInternAtom(d_display, "_GNUSTEP_WM_FUNCTION", 0);
deleteWin=XInternAtom(d_display, "WM_DELETE_WINDOW", 0);
w_root=DefaultRootWindow(d_display);
shints.x=0;
shints.y=0;
shints.flags=0;
pos=(XWMGeometry(d_display, DefaultScreen(d_display), position, NULL, 0, &shints, &shints.x, &shints.y, &shints.width, &shints.height, &shints.win_gravity) & (XValue | YValue));
shints.min_width=winsize;
shints.min_height=winsize;
shints.max_width=winsize;
shints.max_height=winsize;
shints.base_width=winsize;
shints.base_height=winsize;
shints.flags=PMinSize | PMaxSize | PBaseSize;
createWin(&w_main, shints.x, shints.y);
if(wmaker || astep || pos)
shints.flags |= USPosition;
if(wmaker)
{
wmhints.initial_state=WithdrawnState;
wmhints.flags=WindowGroupHint | StateHint | IconWindowHint;
createWin(&w_icon, shints.x, shints.y);
w_activewin=w_icon;
wmhints.icon_window=w_icon;
}
else
{
wmhints.initial_state=NormalState;
wmhints.flags=WindowGroupHint | StateHint;
w_activewin=w_main;
}
wmhints.window_group=w_main;
XSetWMHints(d_display, w_main, &wmhints);
XSetWMNormalHints(d_display, w_main, &shints);
XSetCommand(d_display, w_main, argv, argc);
XStoreName(d_display, w_main, NAME);
XSetIconName(d_display, w_main, NAME);
XSetWMProtocols(d_display, w_activewin, &deleteWin, 1);
}
void _refresh( tWindow* p){
Display *d;
Window w;
cairo_surface_t *ps;
cairo_t *cr;
float margx, margy, x1, x2, x3, x4, y1, y2, y3, y4;
if (!p->valid) return; /* might be good for windoze */
if (vb) printf("window _refresh:%p\n",(void*)p);
mutex_lock(&p->mutex);
if (vb) printf("window _refresh got lock\n");
d = p->display;
w = p->window;
/* and blit to X */
ps = cairo_xlib_surface_create(d,
w,
DefaultVisual(d,DefaultScreen(d)),
p->width,
p->height);
if (ps==NULL){
fprintf(stderr, "%s: can't open cairo xlib surface\n",XDisplayName(NULL));
exit(1);
}
cr = cairo_create(ps);
/* centred blit */
margx = (p->width - p->surf_width)/2;
margy = (p->height - p->surf_height)/2;
x1=0; x2=margx; x3=p->width-margx; x4=p->width;
y1=0; y2=margy; y3=p->height-margy; y4=p->height;
cairo_set_source_rgba(cr,0.5,0.5,0.6,1.0);
cairo_rectangle(cr, x1,y1,x2,y4); /* left */
cairo_rectangle(cr, x3,y1,x4,y4); /* right */
cairo_rectangle(cr, x2,y1,x3,y2); /* middle upper */
cairo_rectangle(cr, x2,y3,x3,y4); /* middle lower */
cairo_fill(cr);
/* doesn't like translate of 0.5 here.. */
if (vb) printf("marge:%g,%g\n",margx,margy);
cairo_translate(cr,(int)margx,(int)margy);
cairo_set_source_surface(cr,p->surf,0,0);
cairo_paint(cr);
cairo_destroy(cr);
cairo_surface_flush(ps);
cairo_surface_flush(p->surf);
cairo_surface_destroy(ps);
XFlush(p->display); /* was XSync(p->display,True) */
mutex_unlock(&p->mutex);
}
