int main(int argc, char** argv)
{
// Create display.
Display* dpy = CreateDisplay();
int screen = XDefaultScreen(dpy);
int depth = XDefaultDepth(dpy, screen);
Window root_win = XDefaultRootWindow(dpy);
int numScreens = 1;
Drawable screens[] = { root_win };
axRect dpy_rect = axRect(0, 0, XDisplayWidth(dpy, screen),
XDisplayHeight(dpy, screen));
// Setup GLX.
XVisualInfo* v_info = GetGLXVisualInfo(dpy);
Visual* visual = v_info->visual;
Colormap colormap = XCreateColormap(dpy, root_win, visual, AllocNone);
glEnable(GL_TEXTURE_2D);
// Create window.
axRect window_rect(0, 0, 500, 500);
Window win = CreateWindow(dpy, window_rect, root_win, colormap, v_info);
// Pixmap back_buffer = XCreatePixmap(dpy, win,
// window_rect.size.x, window_rect.size.y,
// screen);
GLXContext glx_context = glXCreateContext(dpy, v_info, NULL, GL_TRUE);
//GC gc;
glXMakeCurrent(dpy, win, glx_context);
//glXMakeCurrent( AX_GLOBAL_DISPLAY, win, gc->GetGLX_GC() );
//Window win = XCreateSimpleWindow(dpy, RootWindow(dpy, s), 10, 10, 660, 200, 1,
// BlackPixel(dpy, s), WhitePixel(dpy, s));
XSelectInput(dpy, win,
StructureNotifyMask |
ExposureMask |
ButtonPressMask |
ButtonReleaseMask |
PointerMotionMask |
EnterWindowMask |
LeaveWindowMask |
FocusChangeMask );
// Show window.
XMapWindow(dpy, win);
//XFlush(dpy);
XStoreName(dpy, win, "axLib");
//XSelectInput(dpy, win, ExposureMask | KeyPressMask);
//XMapWindow(dpy, win);
// #if defined(__APPLE_CC__)
// XStoreName(dpy, win, "Geeks3D.com - X11 window under Mac OS X (Lion)");
// #else
// XStoreName(dpy, win, "Geeks3D.com - X11 window under Linux (Mint 10)");
// #endif
MainLoop(dpy, win, window_rect);
XDestroyWindow(dpy, win);
XCloseDisplay(dpy);
return 0;
}
VideoMode Monitor::GetCurrentVideoMode() {
#if defined(FastOSWindows)
DEVMODE dm;
memset(&dm, 0, sizeof(DEVMODE));
dm.dmSize = sizeof(DEVMODE);
EnumDisplaySettingsEx(mWin32DeviceName.GetWString().mData,
ENUM_CURRENT_SETTINGS, &dm, 0);
return VideoMode(dm.dmPelsWidth, dm.dmPelsHeight,
dm.dmBitsPerPel, dm.dmDisplayFrequency);
#elif defined(FastOSLinux)
XRRScreenResources *xrrScreenResources =
(XRRScreenResources*)mDisplay->GetXRRScreenResources();
::Display *xdisplay = (::Display*)mDisplay->GetXDisplay();
RRMode mode = ((XRRCrtcInfo*)mXRRCrtcInfo)->mode;
// Find matching mode ID
for (Int i = 0; i < xrrScreenResources->nmode; i++) {
if (mode == xrrScreenResources->modes[i].id) {
XRRModeInfo &xrrModeInfo = xrrScreenResources->modes[i];
return VideoMode(xrrModeInfo.width, xrrModeInfo.height,
XDefaultDepth(xdisplay, mID), (Int)(xrrModeInfo.dotClock /
(xrrModeInfo.hTotal * xrrModeInfo.vTotal)));
}
}
return VideoMode();
#elif defined(FastOSMacOSX)
VideoMode vm;
QZGetCurrentVideoMode(mMacMonitorID, &vm);
return vm;
#endif
}
bool getAvailableDisplayModes(list<DisplayMode> * lstDisplayModes)
{
Display * display;
XF86VidModeModeInfo ** modes;
int nbModes;
display = XOpenDisplay(0);
int screen = DefaultScreen(display);
int bpp = XDefaultDepth(display, screen);
XF86VidModeGetAllModeLines(display, screen, &nbModes, &modes);
for (int i = 0; i < nbModes; i++) {
// Check it's not already added
bool skip = false;
for (DisplayMode &mode : (*lstDisplayModes)) {
if (mode.iWidth == modes[i]->hdisplay && mode.iHeight == modes[i]->vdisplay) {
skip = true;
break;
}
}
if (!skip) {
lstDisplayModes->push_back(DisplayMode(modes[i]->hdisplay, modes[i]->vdisplay, bpp));
}
}
XFree(modes);
return true;
}
static display init(XRRScreenResources* sr, RROutput output)
{
display result;
XRROutputInfo* oi = XRRGetOutputInfo(g_display, sr, output);
if (oi->connection == RR_Connected)
{
result.scale = 1;
result.name = oi->name;
result.color_depth = XDefaultDepth(g_display, g_screen);
result.color_depth_per_component = result.color_depth >= 24? 8 : 0;
result.crtc = oi->crtc;
result.output = output;
XRRCrtcInfo* ci = XRRGetCrtcInfo(g_display, sr, oi->crtc);
result.rect.left = ci->x;
result.rect.top = ci->y;
result.rect.width = ci->width;
result.rect.height = ci->height;
if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
{
std::swap(result.rect.width, result.rect.height);
}
XRRFreeCrtcInfo(ci);
result.work_rect = result.rect;
}
XRRFreeOutputInfo(oi);
return result;
}
void
x_resize(size_t width, size_t height)
{
if (X.win_width == width && X.win_height == height) {
return;
}
debug("%lux%lu", (long unsigned)width, (long unsigned)height);
/* Update pixmap */
if (X.pixmap)
XFreePixmap(X.dpy, X.pixmap);
X.pixmap = XCreatePixmap(X.dpy,
X.window,
width, height,
XDefaultDepth(X.dpy, X.screen));
XSetForeground(X.dpy,
X.gc,
config.background);
XFillRectangle(X.dpy,
X.pixmap,
X.gc,
0, 0,
width, height);
X.win_width = width;
X.win_height = height;
size_t glyphs_w = X.win_width / X.glyph_width;
size_t glyphs_h = X.win_height / X.glyph_height;
term_resize(glyphs_w, glyphs_h);
}
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);
}
void getimage(int left, int top, int right, int bottom, void *bitmap)
{
int X;
int Y;
int width;
int height;
bgi_image *bm = (bgi_image*)bitmap;
Pixmap pixmap;
XGCValues op_gcv;
GC op_gc;
X = left + VPorigin.x;
Y = top + VPorigin.y;
width = right - left + 1;
height = bottom - top + 1;
pixmap = XCreatePixmap(dpy, window, width, height,
XDefaultDepth(dpy, DefaultScreen(dpy)));
op_gc = XCreateGC(dpy, drawable, 0, NULL);
XCopyGC(dpy, gc, (GCBackground | GCForeground | GCPlaneMask),
op_gc);
op_gcv.function = GXcopy;
XChangeGC(dpy, op_gc, GCFunction, &op_gcv);
XCopyArea(dpy, drawable, pixmap, op_gc, X, Y, width, height, 0, 0);
bm->width = width;
bm->height = height;
bm->pixmap = pixmap;
XFreeGC(dpy, op_gc);
}
void xresize(struct framebuffer *xw, struct terminal *term, XEvent *ev)
{
XConfigureEvent *e = &ev->xconfigure;
if (e->width != term->width || e->height != term->height) {
term->width = e->width;
term->height = e->height;
term->lines = term->height / cell_height;
term->cols = term->width / cell_width;
XFreePixmap(xw->dpy, xw->buf);
xw->buf = XCreatePixmap(xw->dpy, xw->win,
term->width, term->height, XDefaultDepth(xw->dpy, xw->sc));
free(term->line_dirty);
term->line_dirty = (bool *) emalloc(sizeof(bool) * term->lines);
free(term->tabstop);
term->tabstop = (bool *) emalloc(sizeof(bool) * term->cols);
free(term->cells);
term->cells = (struct cell *) emalloc(sizeof(struct cell) * term->cols * term->lines);
reset(term);
ioctl(term->fd, TIOCSWINSZ, &(struct winsize)
{.ws_row = term->lines, .ws_col = term->cols, .ws_xpixel = 0, .ws_ypixel = 0});
int createPixmapForTexture(GLXContextType *glxContext, GLuint texture, uint32_t width, uint32_t height, Pixmap *pixmap, GLXPixmap *glxPixmap)
{
int i;
if (!glxContext || !texture || !width || !height || !pixmap || !glxPixmap)
return -1;
Display *x11Display = glxContext->x11Display;
// query/choose config/attributes for GLXPixmap/Pixmap
const int pixmapAttr[] = { GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGB_EXT,
GL_NONE};
const int fbConfigAttr[] = { GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT,
GLX_BIND_TO_TEXTURE_RGB_EXT, GL_TRUE,
GLX_Y_INVERTED_EXT, GL_TRUE,
GL_NONE};
int numFbConfigs;
GLXFBConfig *fbConfig = glXChooseFBConfig(x11Display, DefaultScreen(x11Display), fbConfigAttr, &numFbConfigs);
ASSERT(fbConfig && numFbConfigs);
int depth = XDefaultDepth(x11Display, DefaultScreen(x11Display));
*pixmap = XCreatePixmap(x11Display, DEFAULT_ROOT_WINDOW(x11Display), width, height, depth);
ASSERT(*pixmap);
*glxPixmap = glXCreatePixmap(x11Display, *fbConfig, *pixmap, pixmapAttr);
ASSERT(*glxPixmap);
glBindTexture(GL_TEXTURE_2D, texture);
glXBindTexImageEXT_func(x11Display, *glxPixmap, GLX_FRONT_LEFT_EXT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
ASSERT_GL_ERROR();
return 0;
}
static xrandrt_t *xrandrt_init(const char *display_name)
{
xrandrt_t *xr;
int fd;
Display *disp;
disp = XOpenDisplay(display_name);
if ((xr = malloc(sizeof(*xr))) == NULL) {
if (disp != NULL)
XCloseDisplay(disp);
}
else {
fd = XConnectionNumber(disp);
memset(xr, 0, sizeof(*xr));
xr->disp = disp;
xr->chan = g_io_channel_unix_new(fd);
xr->evsrc = g_io_add_watch(xr->chan, G_IO_IN|G_IO_HUP|G_IO_ERR,
xevent_cb,xr);
printf("videoep: xrandr initialized\n");
{
Window root;
Visual *vis;
int sno;
unsigned long wp;
unsigned long bp;
Window win;
int depth;
XSetWindowAttributes attr;
unsigned long mask;
root = XDefaultRootWindow(disp);
sno = XDefaultScreen(disp);
vis = XDefaultVisual(disp, sno);
depth = XDefaultDepth(disp, sno);
bp = XBlackPixel(disp, sno);
wp = XWhitePixel(disp, sno);
mask = CWBackPixel | CWBorderPixel | CWEventMask;
attr.background_pixel = wp;
attr.border_pixel = bp;
attr.event_mask = ButtonPressMask | FocusChangeMask;
win = XCreateWindow(disp, root, 50,50, 400,300, 1, depth,
InputOutput, vis, mask, &attr);
XMapWindow(disp,win);
XFlush(disp);
}
}
return xr;
}
static inline int displayDepth()
{
#if PLATFORM(QT)
return XDefaultDepth(NetscapePlugin::x11HostDisplay(), x11Screen());
#elif PLATFORM(GTK)
return gdk_visual_get_depth(gdk_screen_get_system_visual(gdk_screen_get_default()));
#else
return 0;
#endif
}
value caml_gr_new_image(int w, int h)
{
value res = alloc_custom(&image_ops, sizeof(struct grimage),
w * h, Max_image_mem);
Width_im(res) = w;
Height_im(res) = h;
Data_im(res) = XCreatePixmap(caml_gr_display, caml_gr_window.win, w, h,
XDefaultDepth(caml_gr_display, caml_gr_screen));
Mask_im(res) = None;
return res;
}
void
subScreenResize(void)
{
int i;
assert(subtle);
/* Update screens */
for(i = 0; i < subtle->screens->ndata; i++)
{
SubScreen *s = SCREEN(subtle->screens->data[i]);
/* Add strut */
s->geom.x = s->base.x + subtle->styles.subtle.padding.left;
s->geom.y = s->base.y + subtle->styles.subtle.padding.top;
s->geom.width = s->base.width - subtle->styles.subtle.padding.left -
subtle->styles.subtle.padding.right;
s->geom.height = s->base.height - subtle->styles.subtle.padding.top -
subtle->styles.subtle.padding.bottom;
/* Update panels */
if(s->flags & SUB_SCREEN_PANEL1)
{
XMoveResizeWindow(subtle->dpy, s->panel1, s->base.x, s->base.y,
s->base.width, subtle->ph);
XMapRaised(subtle->dpy, s->panel1);
/* Update height */
s->geom.y += subtle->ph;
s->geom.height -= subtle->ph;
}
else XUnmapWindow(subtle->dpy, s->panel1);
if(s->flags & SUB_SCREEN_PANEL2)
{
XMoveResizeWindow(subtle->dpy, s->panel2, s->base.x,
s->base.y + s->base.height - subtle->ph, s->base.width, subtle->ph);
XMapRaised(subtle->dpy, s->panel2);
/* Update height */
s->geom.height -= subtle->ph;
}
else XUnmapWindow(subtle->dpy, s->panel2);
/* Create/update drawable for double buffering */
if(s->drawable) XFreePixmap(subtle->dpy, s->drawable);
s->drawable = XCreatePixmap(subtle->dpy, ROOT, s->base.width, subtle->ph,
XDefaultDepth(subtle->dpy, DefaultScreen(subtle->dpy)));
}
ScreenPublish();
subSubtleLogDebugSubtle("Resize\n");
} /* }}} */
static inline int displayDepth()
{
#if PLATFORM(QT)
return XDefaultDepth(NetscapePlugin::x11HostDisplay(), x11Screen());
#elif PLATFORM(GTK)
return gdk_visual_get_depth(gdk_screen_get_system_visual(gdk_screen_get_default()));
#elif PLATFORM(EFL) && defined(HAVE_ECORE_X)
return ecore_x_default_depth_get(NetscapePlugin::x11HostDisplay(), ecore_x_default_screen_get());
#else
return 0;
#endif
}
void xresize(xwindow *xw, terminal *term, XEvent *ev)
{
int lines, cols;
XFreePixmap(xw->dsp, xw->buf);
lines = ev->xconfigure.height / term->cell_size.y;
cols = ev->xconfigure.width / term->cell_size.x;
xw->buf = XCreatePixmap(xw->dsp, xw->win,
ev->xconfigure.width, ev->xconfigure.height,
XDefaultDepth(xw->dsp, xw->sc));
resize(term, lines, cols);
}
struct pipe_screen*
vl_screen_create(Display *display, int screen)
{
struct xsp_pipe_winsys *xsp_winsys;
assert(display);
xsp_winsys = CALLOC_STRUCT(xsp_pipe_winsys);
if (!xsp_winsys)
return NULL;
xsp_winsys->base.buffer_create = xsp_buffer_create;
xsp_winsys->base.user_buffer_create = xsp_user_buffer_create;
xsp_winsys->base.buffer_map = xsp_buffer_map;
xsp_winsys->base.buffer_unmap = xsp_buffer_unmap;
xsp_winsys->base.buffer_destroy = xsp_buffer_destroy;
xsp_winsys->base.surface_buffer_create = xsp_surface_buffer_create;
xsp_winsys->base.fence_reference = xsp_fence_reference;
xsp_winsys->base.fence_signalled = xsp_fence_signalled;
xsp_winsys->base.fence_finish = xsp_fence_finish;
xsp_winsys->base.flush_frontbuffer = xsp_flush_frontbuffer;
xsp_winsys->base.get_name = xsp_get_name;
xsp_winsys->base.destroy = xsp_destroy;
xsp_winsys->display = display;
xsp_winsys->screen = screen;
xsp_winsys->fbimage = XCreateImage
(
display,
XDefaultVisual(display, screen),
XDefaultDepth(display, screen),
ZPixmap,
0,
NULL,
0, /* Don't know the width and height until flush_frontbuffer */
0,
32,
0
);
if (!xsp_winsys->fbimage) {
FREE(xsp_winsys);
return NULL;
}
XInitImage(xsp_winsys->fbimage);
return softpipe_create_screen(&xsp_winsys->base);
}
/* Procedure d'initialisation du serveur X et des variables globales*/
void Xinit(int IsFather)
{
char *name;
Atom myatom;
int i=16;
/* Connextion au serveur X */
#ifdef DEBUG
__bounds_debug_no_checking=True;
#endif
x11base->display=XOpenDisplay(NULL);
if (x11base->display==NULL)
{
fprintf(stderr,"Enable to open display.\n");
exit(1);
}
#ifdef DEBUG
__bounds_debug_no_checking=False;
#endif
if (IsFather)
{
name=(char*)calloc(sizeof(char),strlen("FvwmScript")+5);
do
{
sprintf(name,"%c%xFvwmScript",161,i);
i++;
myatom=XInternAtom(x11base->display,name,False);
}
while (XGetSelectionOwner(x11base->display,myatom)!=None);
x11base->TabScriptId[1]=name;
x11base->TabScriptId[0]=NULL;
}
x11base->NbChild=0;
x11base->screen=DefaultScreen(x11base->display);
x11base->WhitePix=WhitePixel(x11base->display,x11base->screen);
x11base->BlackPix=BlackPixel(x11base->display,x11base->screen);
x11base->depth=XDefaultDepth(x11base->display,x11base->screen);
x11base->colormap = DefaultColormap(x11base->display,x11base->screen);
x11base->root = RootWindow(x11base->display,x11base->screen);
x_fd = XConnectionNumber(x11base->display);
}
display display::from_window(window const* w)
{
Window root = w? *w : g_root;
display result;
if (randr.is_available)
{
XRRScreenResources* sr = XRRGetScreenResources(g_display, root);
RROutput primary = XRRGetOutputPrimary(g_display, g_root);
result = init(sr, primary);
XRRFreeScreenResources(sr);
}
else
{
result.scale = 1;
result.color_depth = XDefaultDepth(g_display, g_screen);
result.color_depth_per_component = result.color_depth >= 24? 8 : 0;
result.rect = result.work_rect = rectangle<int>(0, 0,
DisplayWidthMM(g_display, g_screen), DisplayHeightMM(g_display, g_screen));
}
return result;
}
XVisualInfo *glXChooseVisual(Display *display,
int screen,
int *attributes) {
// apparently can't trust the Display I'm passed?
if (xDisplay == NULL) {
xDisplay = display;
}
int default_depth = XDefaultDepth(display, screen);
if (default_depth != 16 && default_depth != 24)
printf("libGL: unusual desktop color depth %d\n", default_depth);
XVisualInfo *visual = (XVisualInfo *)malloc(sizeof(XVisualInfo));
if (!XMatchVisualInfo(display, screen, default_depth, TrueColor, visual)) {
printf("libGL: XMatchVisualInfo failed in glXChooseVisual\n");
return NULL;
}
return visual;
}
/* ------------------------------------------------------------------ */
int initGraphics()
{
theDisplay = XOpenDisplay(XDisplayName(NULL));
if (theDisplay == NULL) {
printf("You need to run the program under X-window.\n\n");
exit(1);
}
theScreen = XDefaultScreen(theDisplay);
rootW = RootWindow(theDisplay, theScreen);
theGC = XDefaultGC(theDisplay, theScreen);
theCmap = XDefaultColormap(theDisplay, theScreen);
theVisual = DefaultVisual(theDisplay, theScreen);
theDepth = XDefaultDepth(theDisplay, theScreen);
// fprintf(stderr, "Visual %x Depth %d\n", theVisual, theDepth);
pScreen = XDefaultScreenOfDisplay(theDisplay);
sW = XWidthOfScreen(pScreen);
sH = XHeightOfScreen(pScreen);
theFont = XLoadFont(theDisplay, FONT10 );
XSetFont(theDisplay, theGC, theFont);
return 0;
}
value caml_gr_resize_window (value vx, value vy)
{
caml_gr_check_open ();
caml_gr_window.w = Int_val (vx);
caml_gr_window.h = Int_val (vy);
XResizeWindow (caml_gr_display, caml_gr_window.win, caml_gr_window.w,
caml_gr_window.h);
XFreeGC(caml_gr_display, caml_gr_bstore.gc);
XFreePixmap(caml_gr_display, caml_gr_bstore.win);
caml_gr_bstore.w = caml_gr_window.w;
caml_gr_bstore.h = caml_gr_window.h;
caml_gr_bstore.win =
XCreatePixmap(caml_gr_display, caml_gr_window.win, caml_gr_bstore.w,
caml_gr_bstore.h,
XDefaultDepth(caml_gr_display, caml_gr_screen));
caml_gr_bstore.gc = XCreateGC(caml_gr_display, caml_gr_bstore.win, 0, NULL);
XSetBackground(caml_gr_display, caml_gr_bstore.gc, caml_gr_background);
caml_gr_clear_graph ();
return Val_unit;
}
/* Funktion erzeugt ein Fenster */
static int create_window (void) {
char *window_name = "Einfaches Fenster - hallo_x";
char *icon_name = "window";
static XSizeHints size_hints;
Window rootwin;
width = WINDOW_WIDTH;
height = WINDOW_HEIGHT;
/* X-Sitzung öffnen */
display = XOpenDisplay (NULL);
/* Fehlerüberprüfung */
if (display == NULL) {
printf ("Verbindung zum X-Server fehlgeschlagen?!?\n");
exit(EXIT_FAILURE);
}
/* Standardbildschirm eines Displays */
screen = XDefaultScreen (display);
/* Standardtiefe des Screens - Anzahl der Ebenen */
depth = XDefaultDepth (display, screen);
rootwin = RootWindow (display, screen);
win = XCreateSimpleWindow ( display, rootwin, 100, 10,
width, height, 5,
BlackPixel (display, screen),
WhitePixel (display, screen) );
size_hints.flags = PSize | PMinSize | PMaxSize;
size_hints.min_width = width;
size_hints.max_width = width;
size_hints.min_height = height;
size_hints.max_height = height;
XSetStandardProperties ( display, win, window_name, icon_name,
None, 0, 0, &size_hints );
/* Erwünschte Events, auf die das Fenster reagieren soll ... */
XSelectInput (display, win, ButtonPressMask | KeyPressMask);
/* Fenster anzeigen */
XMapWindow (display, win);
return 1;
}
int
main(int argc, char ** argv)
{
setbuf(stdout, NULL);
setbuf(stderr, NULL);
Display * display = XOpenDisplay(NULL);
assert(display != NULL);
XSynchronize(display, True);
XtAppContext context = XtCreateApplicationContext();
Widget appshell = XtVaAppInitialize(&context, "SoXtTest", NULL, 0, &argc, argv, NULL, NULL);
fprintf(stderr, "appshell: %p\n", appshell);
#if WANT_VISUALID
int i, numvisuals;
unsigned int wanted = WANT_VISUALID;
XVisualInfo templ;
XVisualInfo * visuals = XGetVisualInfo(display, VisualNoMask, &templ, &numvisuals);
for ( i = 0; i < numvisuals; i++ ) {
if ( visuals[i].visualid == wanted ) goto selected;
}
assert(0 && "no visual selected");
selected:
Visual * visual = visuals[i].visual;
int visualid = visuals[i].visualid;
int depth = visuals[i].depth;
Colormap colormap = 0;
fprintf(stderr, "visualid: %d, depth: %d, class: %s\n", visualid, depth, visuals[i].c_class == DirectColor ? "DirectColor" : "Other");
int numcmaps;
XStandardColormap * stdcolormaps = NULL;
if ( XmuLookupStandardColormap(display, visuals[i].screen, visuals[i].visualid, visuals[i].depth,
XA_RGB_DEFAULT_MAP, False, True) &&
XGetRGBColormaps(display, RootWindow(display, visuals[i].screen),
&stdcolormaps, &numcmaps, XA_RGB_DEFAULT_MAP) ) {
for ( int j = 0; j < numcmaps; j++ ) {
if (stdcolormaps[j].visualid == visuals[i].visualid) {
colormap = stdcolormaps[j].colormap;
goto cont;
}
}
colormap = XCreateColormap(display, RootWindow(display, visuals[i].screen), visuals[i].visual, AllocNone);
fprintf(stderr, "standard RGB colormaps did not work with visual - created own (%ld)", colormap);
} else {
assert(0);
}
cont:
fprintf(stderr, "colormap: %ld\n", colormap);
#else
Visual * visual = NULL;
int depth = 0;
Colormap colormap = 0;
int snum = XDefaultScreen(display);
visual = XDefaultVisual(display, snum);
depth = XDefaultDepth(display, snum);
colormap = XDefaultColormap(display, snum);
fprintf(stderr, "visual: %p, depth: %d\n", visual, depth);
fprintf(stderr, "colormap: %ld\n", colormap);
#endif
XtVaSetValues(appshell,
XmNwidth, 100,
XmNheight, 100,
XmNvisual, visual,
XmNcolormap, colormap,
XmNdepth, depth,
NULL);
Widget form = XtVaCreateManagedWidget(
"form", xmFormWidgetClass,
appshell,
NULL);
Widget button = XtVaCreateManagedWidget(
"button", xmPushButtonWidgetClass,
form,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
Pixmap pixmap = createPixmapFromXpm(button, home_xpm);
XtVaSetValues(button,
XmNlabelType, XmPIXMAP,
XmNlabelPixmap, pixmap,
XmNlabelInsensitivePixmap, pixmap,
XmNselectPixmap, pixmap,
XmNselectInsensitivePixmap, pixmap,
NULL);
Widget list[] = { appshell, form, button, NULL };
XtSetWMColormapWindows(appshell, list, 3);
XtRealizeWidget(appshell);
XtAppMainLoop(context);
}
void
main(int argc, char **argv)
{
XmStringTable ColumnDetails;
int i,j;
Cardinal n;
Arg args[MAX_ARGS];
int test_num;
char test_char;
char ContainerName[NAME_LEN + 1];
Pixmap CollapsedStatePixmap, ExpandedStatePixmap;
ContainerName[0] = '\0';
test_num = 0;
test_char = '\0';
CommonTestInit(argc, argv);
if (UserData != NULL) {
if (strcmp(UserData, "a") == 0)
test_num = 1;
else if (strcmp(UserData, "b") == 0)
test_num = 2;
else if (strcmp(UserData, "c") == 0)
test_num = 3;
else if (strcmp(UserData, "d") == 0)
test_num = 4;
test_char = *UserData;
free(UserData);
}
sprintf(ContainerName, "Container3%c", test_char);
CollapsedStatePixmap = XCreatePixmapFromBitmapData(display, rootWindow,
collapsedState_bits,
collapsedState_width,
collapsedState_height,
CommonGetColor("black"),
CommonGetColor("white"),
XDefaultDepth(display,
XDefaultScreen(display)));
ExpandedStatePixmap = XCreatePixmapFromBitmapData(display, rootWindow,
expandedState_bits,
expandedState_width,
expandedState_height,
CommonGetColor("white"),
CommonGetColor("black"),
XDefaultDepth(display,
XDefaultScreen(display)));
ColumnHeadings = (XmStringTable) XtMalloc(NUM_COL * sizeof(XmString));
for (i = 0; i < NUM_COL; i++)
ColumnHeadings[i] = XmStringGenerate(ColumnHeadingText[i],
NULL,
XmCHARSET_TEXT,
NULL);
n = 0;
XtSetArg(args[n], XmNentryViewType, XmLARGE_ICON); n++;
XtSetArg(args[n], XmNlayoutType, XmOUTLINE); n++;
XtSetArg(args[n], XmNautomaticSelection, XmNO_AUTO_SELECT); n++;
XtSetArg(args[n], XmNdetailColumnHeading, ColumnHeadings); n++;
XtSetArg(args[n], XmNdetailColumnHeadingCount, NUM_COL); n++;
XtSetArg(args[n], XmNdetailOrderCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNcollapsedStatePixmap, CollapsedStatePixmap); n++;
XtSetArg(args[n], XmNexpandedStatePixmap, ExpandedStatePixmap); n++;
Container3 = XmCreateContainer(Shell1, ContainerName, args, n);
XtManageChild(Container3);
EntryDetails = (XmStringTable *) XtMalloc(NUM_OBJ * sizeof(XmStringTable));
for (i = 0; i < NUM_OBJ; i++) {
ColumnDetails = (XmStringTable)XtMalloc((NUM_COL-1) * sizeof(XmString));
ColumnDetails[0] = XmStringGenerate(FullTitleText[i],
NULL,
XmCHARSET_TEXT,
NULL);
ColumnDetails[1] = XmStringGenerate(FlavorText[i],
NULL,
XmCHARSET_TEXT,
NULL);
ColumnDetails[2] = XmStringGenerate(AgeText[i],
NULL,
XmCHARSET_TEXT,
NULL);
EntryDetails[i] = ColumnDetails;
}
n = 0;
XtSetArg(args[n], XmNx, 100); n++;
XtSetArg(args[n], XmNy, 100); n++;
XtSetArg(args[n], XmNentryViewType, XmSMALL_ICON); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[0]); n++;
IconGad1 = XmCreateIconGadget(Container3, "IconGad1", args, n);
XtManageChild(IconGad1);
n = 0;
XtSetArg(args[n], XmNx, 200); n++;
XtSetArg(args[n], XmNy, 200); n++;
XtSetArg(args[n], XmNentryViewType, XmSMALL_ICON); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[1]); n++;
IconGad2 = XmCreateIconGadget(Container3, "IconGad2", args, n);
XtManageChild(IconGad2);
n = 0;
XtSetArg(args[n], XmNx, 300); n++;
XtSetArg(args[n], XmNy, 100); n++;
XtSetArg(args[n], XmNentryViewType, XmLARGE_ICON); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[2]); n++;
IconGad3 = XmCreateIconGadget(Container3, "IconGad3", args, n);
XtManageChild(IconGad3);
n = 0;
XtSetArg(args[n], XmNx, 50); n++;
XtSetArg(args[n], XmNy, 400); n++;
XtSetArg(args[n], XmNentryViewType, XmSMALL_ICON); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[3]); n++;
IconGad4 = XmCreateIconGadget(Container3, "IconGad4", args, n);
XtManageChild(IconGad4);
n = 0;
XtSetArg(args[n], XmNentryParent, IconGad3); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNentryViewType, XmSMALL_ICON); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[4]); n++;
IconGad31 = XmCreateIconGadget(Container3, "IconGad31", args, n);
XtManageChild(IconGad31);
n = 0;
XtSetArg(args[n], XmNentryParent, IconGad3); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNentryViewType, XmSMALL_ICON); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[5]); n++;
IconGad32 = XmCreateIconGadget(Container3, "IconGad32", args, n);
XtManageChild(IconGad32);
n = 0;
XtSetArg(args[n], XmNentryParent, IconGad32); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNentryViewType, XmLARGE_ICON); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[6]); n++;
IconGad321 = XmCreateIconGadget(Container3, "IconGad321", args, n);
XtManageChild(IconGad321);
n = 0;
XtSetArg(args[n], XmNentryParent, IconGad321); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNentryViewType, XmLARGE_ICON); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[7]); n++;
IconGad3211 = XmCreateIconGadget(Container3, "IconGad3211", args, n);
XtManageChild(IconGad3211);
n = 0;
XtSetArg(args[n], XmNentryParent, IconGad3); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNentryViewType, XmSMALL_ICON); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[8]); n++;
IconGad33 = XmCreateIconGadget(Container3, "IconGad33", args, n);
XtManageChild(IconGad33);
for (i = 0; i < NUM_OBJ; i++) {
ColumnDetails = EntryDetails[i];
for (j = 0; j < NUM_COL-1; j++)
XmStringFree(ColumnDetails[j]);
XtFree((XtPointer)ColumnDetails);
}
XtFree((XtPointer)EntryDetails);
XtRealizeWidget(Shell1);
CommonPause();
if ((test_num == 1) || (test_num == 2)) {
CommonPause();
CommonPause();
CommonPause();
CommonPause();
CommonPause();
for (i = 0; i < NUM_COL; i++)
XmStringFree(ColumnHeadings[i]);
XtFree((XtPointer)ColumnHeadings);
}
if (test_num == 3) {
CommonPause();
for (i = 0; i < NUM_COL; i++)
XmStringFree(ColumnHeadings[i]);
XtFree((XtPointer)ColumnHeadings);
}
XtAppMainLoop(app_context);
}
static void vo_x11_zoom (int mulriple)
{
unsigned long xswamask, event_mask;
XSetWindowAttributes xswa;
XSizeHints hint;
XVisualInfo xvinfo;
if (dlpctxp->pwidth * mulriple > screen_width || dlpctxp->pheight * mulriple > screen_height)
{
av_log (NULL, AV_LOG_INFO, "vo x11: zoom %d will > fullscrren\n", mulriple);
return;
}
vo_lock ();
if (Xvowin != None)
{
XClearWindow (Xdisplay, Xvowin);
XUnmapWindow (Xdisplay, Xvowin);
XDestroyWindow (Xdisplay, Xvowin);
Xvowin = None;
}
if (Ximg)
{
Ximg->data = NULL;
XDestroyImage (Ximg);
Ximg = NULL;
}
avpicture_free (my_pic);
av_free (my_pic);
xswamask = CWBackingStore | CWBorderPixel;
dw = dlpctxp->pwidth * mulriple;
dh = dlpctxp->pheight * mulriple;
dx = (screen_width - dw) / 2;
dy = (screen_height - dh) / 2;
Xdepth = XDefaultDepth (Xdisplay, 0);
if (!XMatchVisualInfo (Xdisplay, Xscreen, Xdepth, DirectColor, &xvinfo))
XMatchVisualInfo (Xdisplay, Xscreen, Xdepth, TrueColor, &xvinfo);
xswa.background_pixel = 0;
xswa.border_pixel = 0;
xswa.backing_store = Always;
xswa.bit_gravity = StaticGravity;
Xvowin = XCreateWindow (Xdisplay, Xrootwin, dx, dy, dw, dh, 0, Xdepth, CopyFromParent, CopyFromParent, xswamask, &xswa);
hint.x = dx;
hint.y = dy;
hint.width = dw;
hint.height = dh;
hint.flags = PPosition | PSize;
XSetStandardProperties (Xdisplay, Xvowin, Xtitle, Xtitle, None, NULL, 0, &hint);
XMapWindow (Xdisplay, Xvowin);
XClearWindow (Xdisplay, Xvowin);
event_mask = StructureNotifyMask | KeyPressMask | ExposureMask;
XSelectInput (Xdisplay, Xvowin, event_mask);
XSync (Xdisplay, False);
Ximg = XCreateImage (Xdisplay, xvinfo.visual, Xdepth, ZPixmap, 0, NULL, dw, dh, 8, 0);
if (dw < 600)
Xfont = Xfont_120;
else
Xfont = Xfont_240;
if (Xfont)
XSetFont (Xdisplay, Xvogc, Xfont->fid);
my_pic = av_mallocz (sizeof (AVPicture));
avpicture_alloc (my_pic, my_pic_fmt, dw, dh);
vo_unlock ();
}
static int vo_x11_init ()
{
int ret;
unsigned long xswamask, event_mask;
XSetWindowAttributes xswa;
XSizeHints hint;
XVisualInfo xvinfo;
char *dspname;
xswamask = CWBackingStore | CWBorderPixel;
src_pic_fmt = dlpctxp->pixfmt;
dw = dlpctxp->pwidth;
dh = dlpctxp->pheight;
dspname = XDisplayName (NULL);
av_log (NULL, AV_LOG_INFO, "Open X11 display %s\n", dspname);
Xdisplay = XOpenDisplay (dspname);
if (!Xdisplay)
{
av_log (NULL, AV_LOG_ERROR, "X11,%d: XOpenDisplay\n", __LINE__);
return -1;
}
Xscreen = DefaultScreen (Xdisplay);
Xrootwin = RootWindow (Xdisplay, Xscreen);
screen_width = DisplayWidth (Xdisplay, Xscreen);
screen_height = DisplayHeight (Xdisplay, Xscreen);
dx = (screen_width - dw) / 2;
dy = (screen_height - dh) / 2;
Xdepth = XDefaultDepth (Xdisplay, 0);
if (!XMatchVisualInfo (Xdisplay, Xscreen, Xdepth, DirectColor, &xvinfo))
XMatchVisualInfo (Xdisplay, Xscreen, Xdepth, TrueColor, &xvinfo);
xswa.background_pixel = 0;
xswa.border_pixel = 0;
xswa.backing_store = Always;
xswa.bit_gravity = StaticGravity;
Xvowin = XCreateWindow (Xdisplay, Xrootwin, dx, dy, dw, dh, 0, Xdepth, CopyFromParent, CopyFromParent, xswamask, &xswa);
hint.x = dx;
hint.y = dy;
hint.width = dw;
hint.height = dh;
hint.flags = PPosition | PSize;
XSetStandardProperties (Xdisplay, Xvowin, Xtitle, Xtitle, None, NULL, 0, &hint);
XMapWindow (Xdisplay, Xvowin);
XClearWindow (Xdisplay, Xvowin);
event_mask = StructureNotifyMask | KeyPressMask | ExposureMask;
XSelectInput (Xdisplay, Xvowin, event_mask);
XSync (Xdisplay, False);
Xvogc = XCreateGC (Xdisplay, Xrootwin, 0L, NULL);
XSetForeground (Xdisplay, Xvogc, WhitePixel (Xdisplay, Xscreen));
Ximg = XCreateImage (Xdisplay, xvinfo.visual, Xdepth, ZPixmap, 0, NULL, dw, dh, 8, 0);
{
int i, fontcount;
char **list;
list = XListFonts (Xdisplay, "-*-helvetica-*-*-*-*-0-0-*-*-*-0-*-*", 200, &fontcount);
for (i = 0; i < fontcount; i++)
{
if (NULL == Xfont_120)
Xfont_120 = LoadQueryScalableFont (Xdisplay, Xscreen, list[i], 120);
if (NULL == Xfont_240)
Xfont_240 = LoadQueryScalableFont (Xdisplay, Xscreen, list[i], 240);
if (Xfont_120 && Xfont_240)
break;
}
XFreeFontNames (list);
if (NULL == Xfont_120 || NULL == Xfont_240)
{
av_log (NULL, AV_LOG_ERROR, "XLoadQueryFont: failed\n");
}
if (dw < 600)
Xfont = Xfont_120;
else
Xfont = Xfont_240;
if (Xfont)
XSetFont (Xdisplay, Xvogc, Xfont->fid);
}
switch (Ximg->bits_per_pixel)
{
case 32:
my_pic_fmt = PIX_FMT_RGB32;
break;
case 24:
my_pic_fmt = PIX_FMT_RGB24;
break;
case 16:
my_pic_fmt = PIX_FMT_RGB565;
break;
case 15:
my_pic_fmt = PIX_FMT_RGB555;
break;
case 8:
my_pic_fmt = PIX_FMT_RGB8;
break;
}
av_log (NULL, AV_LOG_INFO, "bits_per_pixel: %d\n", Ximg->bits_per_pixel);
/*-----------------------------------------------------------------------------
* my picture for rgb
*-----------------------------------------------------------------------------*/
my_pic = av_mallocz (sizeof (AVPicture));
ret = avpicture_alloc (my_pic, my_pic_fmt, dw, dh);
if (-1 == ret)
{
av_log (NULL, AV_LOG_ERROR, "avpicture alloc error\n");
return -1;
}
vo_lock_init ();
return 0;
}
VALUE
subIconInit(int argc,
VALUE *argv,
VALUE self)
{
SubtlextIcon *i = NULL;
Data_Get_Struct(self, SubtlextIcon, i);
if(i)
{
VALUE data[3] = { Qnil };
rb_scan_args(argc, argv, "12", &data[0], &data[1], &data[2]);
subSubtlextConnect(NULL); ///< Implicit open connection
/* Find or create icon */
if(T_STRING == rb_type(data[0])) ///< Icon path
{
int hotx = 0, hoty = 0;
char buf[100] = { 0 };
#ifdef HAVE_WORDEXP_H
/* Expand tildes in path */
wordexp_t we;
if(0 == wordexp(RSTRING_PTR(data[0]), &we, 0))
{
snprintf(buf, sizeof(buf), "%s", we.we_wordv[0]);
wordfree(&we);
}
else
#endif /* HAVE_WORDEXP_H */
snprintf(buf, sizeof(buf), "%s", RSTRING_PTR(data[0]));
/* Find file */
if(-1 == access(buf, R_OK))
{
char *home = NULL;
/* Combine paths */
if((home = getenv("XDG_DATA_HOME")))
{
snprintf(buf, sizeof(buf), "%s/subtle/icons/%s",
home, RSTRING_PTR(data[0]));
}
else
{
snprintf(buf, sizeof(buf), "%s/.local/share/subtle/icons/%s",
getenv("HOME"), RSTRING_PTR(data[0]));
}
if(-1 == access(buf, R_OK))
rb_raise(rb_eStandardError, "Icon not found `%s'",
RSTRING_PTR(data[0]));
}
/* Reading bitmap or pixmap icon file */
if(BitmapSuccess != XReadBitmapFile(display,
DefaultRootWindow(display), buf, &i->width, &i->height,
&i->pixmap, &hotx, &hoty))
{
#ifdef HAVE_X11_XPM_H
XpmAttributes attrs;
/* We could define a color to use on transparent areas, but
* this can be done on init only, so we just ignore it and
* expect pixmaps to have no transparent areas at all */
/* Init attributes */
attrs.colormap = DefaultColormap(display, DefaultScreen(display));
attrs.depth = DefaultDepth(display, DefaultScreen(display));
attrs.visual = DefaultVisual(display, DefaultScreen(display));
attrs.valuemask = XpmColormap|XpmDepth|XpmVisual;
if(XpmSuccess == XpmReadFileToPixmap(display,
DefaultRootWindow(display), buf, &i->pixmap, NULL, &attrs))
{
i->flags |= ICON_PIXMAP;
i->width = attrs.width;
i->height = attrs.height;
}
else
#endif /* HAVE_X11_XPM_H */
{
rb_raise(rb_eStandardError, "Malormed icon");
return Qnil;
}
}
else i->flags |= ICON_BITMAP;
}
else if(FIXNUM_P(data[0]) && FIXNUM_P(data[1])) ///< Icon dimensions
{
int depth = 1;
/* Create pixmap or bitmap */
if(Qtrue == data[2])
{
i->flags |= ICON_PIXMAP;
depth = XDefaultDepth(display, DefaultScreen(display));
}
else i->flags |= ICON_BITMAP;
/* Create empty pixmap */
i->width = FIX2INT(data[0]);
i->height = FIX2INT(data[1]);
i->pixmap = XCreatePixmap(display, DefaultRootWindow(display),
i->width, i->height, depth);
}
else if(FIXNUM_P(data[0]))
{
XRectangle geom = { 0 };
i->flags |= (ICON_BITMAP|ICON_FOREIGN);
i->pixmap = NUM2LONG(data[0]);
subSharedPropertyGeometry(display, i->pixmap, &geom);
i->width = geom.width;
i->height = geom.height;
}
else rb_raise(rb_eArgError, "Unexpected value-types");
/* Update object */
rb_iv_set(i->instance, "@width", INT2FIX(i->width));
rb_iv_set(i->instance, "@height", INT2FIX(i->height));
rb_iv_set(i->instance, "@pixmap", LONG2NUM(i->pixmap));
XSync(display, False); ///< Sync all changes
subSharedLogDebugSubtlext("new=icon, width=%03d, height=%03d\n",
i->width, i->height);
}
return Qnil;
} /* }}} */
void caml_gr_handle_event(XEvent * event)
{
switch (event->type) {
case Expose:
XCopyArea(caml_gr_display, caml_gr_bstore.win, caml_gr_window.win, caml_gr_window.gc,
event->xexpose.x, event->xexpose.y + caml_gr_bstore.h - caml_gr_window.h,
event->xexpose.width, event->xexpose.height,
event->xexpose.x, event->xexpose.y);
XFlush(caml_gr_display);
break;
case ConfigureNotify:
caml_gr_window.w = event->xconfigure.width;
caml_gr_window.h = event->xconfigure.height;
if (caml_gr_window.w > caml_gr_bstore.w || caml_gr_window.h > caml_gr_bstore.h) {
/* Allocate a new backing store large enough to accomodate
both the old backing store and the current window. */
struct canvas newbstore;
newbstore.w = max(caml_gr_window.w, caml_gr_bstore.w);
newbstore.h = max(caml_gr_window.h, caml_gr_bstore.h);
newbstore.win =
XCreatePixmap(caml_gr_display, caml_gr_window.win, newbstore.w, newbstore.h,
XDefaultDepth(caml_gr_display, caml_gr_screen));
newbstore.gc = XCreateGC(caml_gr_display, newbstore.win, 0, NULL);
XSetBackground(caml_gr_display, newbstore.gc, caml_gr_white);
XSetForeground(caml_gr_display, newbstore.gc, caml_gr_white);
XFillRectangle(caml_gr_display, newbstore.win, newbstore.gc,
0, 0, newbstore.w, newbstore.h);
XSetForeground(caml_gr_display, newbstore.gc, caml_gr_color);
if (caml_gr_font != NULL)
XSetFont(caml_gr_display, newbstore.gc, caml_gr_font->fid);
/* Copy the old backing store into the new one */
XCopyArea(caml_gr_display, caml_gr_bstore.win, newbstore.win, newbstore.gc,
0, 0, caml_gr_bstore.w, caml_gr_bstore.h, 0, newbstore.h - caml_gr_bstore.h);
/* Free the old backing store */
XFreeGC(caml_gr_display, caml_gr_bstore.gc);
XFreePixmap(caml_gr_display, caml_gr_bstore.win);
/* Use the new backing store */
caml_gr_bstore = newbstore;
XFlush(caml_gr_display);
}
break;
case MappingNotify:
XRefreshKeyboardMapping(&(event->xmapping));
break;
case KeyPress:
{ KeySym thekey;
char keytxt[256];
int nchars;
char * p;
nchars = XLookupString(&(event->xkey), keytxt, sizeof(keytxt),
&thekey, 0);
for (p = keytxt; nchars > 0; p++, nchars--)
caml_gr_enqueue_event(event->type, event->xkey.x, event->xkey.y,
BUTTON_STATE(event->xkey.state), *p);
break;
}
case ButtonPress:
case ButtonRelease:
caml_gr_enqueue_event(event->type, event->xbutton.x, event->xbutton.y,
event->type == ButtonPress, 0);
break;
case MotionNotify:
caml_gr_enqueue_event(event->type, event->xmotion.x, event->xmotion.y,
BUTTON_STATE(event->xmotion.state), 0);
break;
}
}
int QWaylandReadbackEglIntegration::depth() const
{
return XDefaultDepth(mDisplay,mScreen);
}
value caml_gr_open_graph(value arg)
{
char display_name[256], geometry_spec[64];
char * p, * q;
XSizeHints hints;
int ret;
XEvent event;
int x, y, w, h;
XWindowAttributes attributes;
if (caml_gr_initialized) {
caml_gr_clear_graph();
} else {
/* Parse the argument */
for (p = String_val(arg), q = display_name; *p != 0 && *p != ' '; p++)
if (q < display_name + sizeof(display_name) - 1) *q++ = *p;
*q = 0;
while (*p == ' ') p++;
for (q = geometry_spec; *p != 0; p++)
if (q < geometry_spec + sizeof(geometry_spec) - 1) *q++ = *p;
*q = 0;
/* Open the display */
if (caml_gr_display == NULL) {
caml_gr_display = XOpenDisplay(display_name);
if (caml_gr_display == NULL)
caml_gr_fail("Cannot open display %s", XDisplayName(display_name));
caml_gr_screen = DefaultScreen(caml_gr_display);
caml_gr_black = BlackPixel(caml_gr_display, caml_gr_screen);
caml_gr_white = WhitePixel(caml_gr_display, caml_gr_screen);
caml_gr_background = caml_gr_white;
caml_gr_colormap = DefaultColormap(caml_gr_display, caml_gr_screen);
}
/* Set up the error handlers */
XSetErrorHandler(caml_gr_error_handler);
XSetIOErrorHandler(caml_gr_ioerror_handler);
/* Parse the geometry specification */
hints.x = 0;
hints.y = 0;
hints.width = DEFAULT_SCREEN_WIDTH;
hints.height = DEFAULT_SCREEN_HEIGHT;
hints.flags = PPosition | PSize;
hints.win_gravity = 0;
ret = XWMGeometry(caml_gr_display, caml_gr_screen, geometry_spec, "", BORDER_WIDTH,
&hints, &x, &y, &w, &h, &hints.win_gravity);
if (ret & (XValue | YValue)) {
hints.x = x; hints.y = y; hints.flags |= USPosition;
}
if (ret & (WidthValue | HeightValue)) {
hints.width = w; hints.height = h; hints.flags |= USSize;
}
/* Initial drawing color is black */
caml_gr_color = 0; /* CAML COLOR */
/* Create the on-screen window */
caml_gr_window.w = hints.width;
caml_gr_window.h = hints.height;
caml_gr_window.win =
XCreateSimpleWindow(caml_gr_display, DefaultRootWindow(caml_gr_display),
hints.x, hints.y, hints.width, hints.height,
BORDER_WIDTH, caml_gr_black, caml_gr_background);
p = window_name;
if (p == NULL) p = DEFAULT_WINDOW_NAME;
/* What not use XSetWMProperties? */
XSetStandardProperties(caml_gr_display, caml_gr_window.win, p, p,
None, NULL, 0, &hints);
caml_gr_window.gc = XCreateGC(caml_gr_display, caml_gr_window.win, 0, NULL);
XSetBackground(caml_gr_display, caml_gr_window.gc, caml_gr_background);
XSetForeground(caml_gr_display, caml_gr_window.gc, caml_gr_black);
/* Require exposure, resize and keyboard events */
caml_gr_selected_events = DEFAULT_SELECTED_EVENTS;
XSelectInput(caml_gr_display, caml_gr_window.win, caml_gr_selected_events);
/* Map the window on the screen and wait for the first Expose event */
XMapWindow(caml_gr_display, caml_gr_window.win);
do { XNextEvent(caml_gr_display, &event); } while (event.type != Expose);
/* Get the actual window dimensions */
XGetWindowAttributes(caml_gr_display, caml_gr_window.win, &attributes);
caml_gr_window.w = attributes.width;
caml_gr_window.h = attributes.height;
/* Create the pixmap used for backing store */
caml_gr_bstore.w = caml_gr_window.w;
caml_gr_bstore.h = caml_gr_window.h;
caml_gr_bstore.win =
XCreatePixmap(caml_gr_display, caml_gr_window.win, caml_gr_bstore.w, caml_gr_bstore.h,
XDefaultDepth(caml_gr_display, caml_gr_screen));
caml_gr_bstore.gc = XCreateGC(caml_gr_display, caml_gr_bstore.win, 0, NULL);
XSetBackground(caml_gr_display, caml_gr_bstore.gc, caml_gr_background);
/* Clear the pixmap */
XSetForeground(caml_gr_display, caml_gr_bstore.gc, caml_gr_background);
XFillRectangle(caml_gr_display, caml_gr_bstore.win, caml_gr_bstore.gc,
0, 0, caml_gr_bstore.w, caml_gr_bstore.h);
XSetForeground(caml_gr_display, caml_gr_bstore.gc, caml_gr_black);
/* Set the display and remember modes on */
caml_gr_display_modeflag = True ;
caml_gr_remember_modeflag = True ;
/* The global data structures are now correctly initialized.
In particular, caml_gr_sigio_handler can now handle events safely. */
caml_gr_initialized = True;
/* If possible, request that system calls be restarted after
the EVENT_SIGNAL signal. */
#ifdef POSIX_SIGNALS
#ifdef SA_RESTART
{ struct sigaction action;
sigaction(EVENT_SIGNAL, NULL, &action);
action.sa_flags |= SA_RESTART;
sigaction(EVENT_SIGNAL, &action, NULL);
}
#endif
#endif
#ifdef USE_ASYNC_IO
/* If BSD-style asynchronous I/O are supported:
arrange for I/O on the connection to trigger the SIGIO signal */
ret = fcntl(ConnectionNumber(caml_gr_display), F_GETFL, 0);
fcntl(ConnectionNumber(caml_gr_display), F_SETFL, ret | FASYNC);
fcntl(ConnectionNumber(caml_gr_display), F_SETOWN, getpid());
#endif
}
#ifdef USE_INTERVAL_TIMER
/* If BSD-style interval timers are provided, use the real-time timer
to poll events. */
{ struct itimerval it;
it.it_interval.tv_sec = 0;
it.it_interval.tv_usec = 250000;
it.it_value.tv_sec = 0;
it.it_value.tv_usec = 250000;
setitimer(ITIMER_REAL, &it, NULL);
}
#endif
#ifdef USE_ALARM
/* The poor man's solution: use alarm to poll events. */
alarm(1);
#endif
/* Position the current point at origin */
caml_gr_x = 0;
caml_gr_y = 0;
/* Reset the color cache */
caml_gr_init_color_cache();
caml_gr_init_direct_rgb_to_pixel();
return Val_unit;
}
