void VlcWindowlessXCB::drawBackground(xcb_drawable_t drawable)
{
/* Obtain the background color */
xcb_colormap_t colormap = m_screen->default_colormap;
unsigned r = 0, g = 0, b = 0;
HTMLColor2RGB(get_options().get_bg_color().c_str(), &r, &g, &b);
xcb_alloc_color_reply_t *reply = xcb_alloc_color_reply(m_conn,
xcb_alloc_color(m_conn, colormap,
(uint16_t) r << 8,
(uint16_t) g << 8,
(uint16_t) b << 8), NULL);
uint32_t colorpixel = reply->pixel;
free(reply);
/* Prepare to fill the background */
xcb_gcontext_t background = xcb_generate_id(m_conn);
uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
uint32_t values[2] = {colorpixel, 0};
xcb_create_gc(m_conn, background, drawable, mask, values);
xcb_rectangle_t rect;
rect.x = 0;
rect.y = 0;
rect.width = npwindow.width;
rect.height = npwindow.height;
/* Fill the background */
xcb_poly_fill_rectangle(m_conn, drawable, background, 1, &rect);
xcb_free_gc(m_conn, background);
}
int
main ()
{
xcb_connection_t* connection;
xcb_screen_t* screen;
xcb_window_t root_window;
xcb_alloc_color_reply_t *color_reply;
xcb_colormap_t colormap = { 0 };
uint32_t params[1];
uint16_t r,g,b;
connection = xcb_connect(NULL, NULL);
if (!connection) {
fprintf(stderr, "ERROR: can't connect to an X server\n");
return -1;
}
screen = xcb_setup_roots_iterator(xcb_get_setup(connection)).data;
if (!screen)
{
fprintf(stderr, "ERROR: can't setup a screen\n");
xcb_disconnect(connection);
return -1;
}
root_window = screen->root;
colormap = screen->default_colormap;
r = 60000, g = 20000, b = 20000;
color_reply = xcb_alloc_color_reply(connection,
xcb_alloc_color(connection, colormap, r, g, b), NULL);
if(!color_reply)
{
fprintf(stderr, "ERROR: can't alloc an color\n");
xcb_disconnect(connection);
return 0;
}
params[0] = color_reply->pixel;
// sets the root_window back_pixel to pixel(params)
xcb_change_window_attributes(connection, root_window, XCB_CW_BACK_PIXEL, params);
// free color resources
free(color_reply);
// waits all things are send??
xcb_flush(connection);
// xcb_destroy_window(connection, window);
xcb_disconnect(connection);
return 0;
}
static
int get_color(const char *str, uint32_t *color)
{
if (str[0] == '#') { /* in hex format */
uint16_t r, g, b;
xcb_alloc_color_cookie_t cookie;
xcb_alloc_color_reply_t *reply;
if (sscanf(str + 1, "%2hx%2hx%2hx", &r, &g, &b) != 3) {
NIL_ERR("color format %s", str);
return -1;
}
cookie = xcb_alloc_color(nil_.con, nil_.scr->default_colormap,
r << 8, g << 8, b << 8);
reply = xcb_alloc_color_reply(nil_.con, cookie, 0);
if (!reply) {
NIL_ERR("no color %s", str);
return -1;
}
*color = reply->pixel;
free(reply);
} else {
xcb_alloc_named_color_cookie_t cookie;
xcb_alloc_named_color_reply_t *reply;
cookie = xcb_alloc_named_color(nil_.con, nil_.scr->default_colormap,
strlen(str), str);
reply = xcb_alloc_named_color_reply(nil_.con, cookie, 0);
if (!reply) {
NIL_ERR("no color %s", str);
return -1;
}
*color = reply->pixel;
free(reply);
}
return 0;
}
ZLEwlViewWidget::ZLEwlViewWidget(ZLApplication *application, ZLView::Angle initialAngle) : ZLViewWidget(initialAngle) {
myApplication = application;
w = 600;
h = 800;
xcb_screen_iterator_t screen_iter;
const xcb_setup_t *setup;
xcb_generic_event_t *e;
xcb_generic_error_t *error;
xcb_void_cookie_t cookie_window;
xcb_void_cookie_t cookie_map;
uint32_t mask;
uint32_t values[2];
int screen_number;
uint8_t is_hand = 0;
xcb_rectangle_t rect_coord = { 0, 0, 600, 800};
/* getting the connection */
connection = xcb_connect (NULL, &screen_number);
if (xcb_connection_has_error(connection)) {
fprintf (stderr, "ERROR: can't connect to an X server\n");
exit(-1);
}
screen = xcb_aux_get_screen (connection, screen_number);
gc = xcb_generate_id (connection);
mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
values[0] = screen->black_pixel;
values[1] = 0; /* no graphics exposures */
xcb_create_gc (connection, gc, screen->root, mask, values);
bgcolor = xcb_generate_id (connection);
mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
values[0] = screen->white_pixel;
values[1] = 0; /* no graphics exposures */
xcb_create_gc (connection, bgcolor, screen->root, mask, values);
/* creating the window */
window = xcb_generate_id(connection);
mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
values[0] = screen->white_pixel;
values[1] =
XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE |
XCB_EVENT_MASK_BUTTON_PRESS |
XCB_EVENT_MASK_EXPOSURE |
XCB_EVENT_MASK_POINTER_MOTION |
XCB_EVENT_MASK_VISIBILITY_CHANGE | XCB_EVENT_MASK_STRUCTURE_NOTIFY |
XCB_EVENT_MASK_FOCUS_CHANGE | XCB_EVENT_MASK_PROPERTY_CHANGE;
uint8_t depth = xcb_aux_get_depth (connection, screen);
xcb_create_window(connection,
depth,
window, screen->root,
0, 0, 600, 800,
0, XCB_WINDOW_CLASS_INPUT_OUTPUT,
screen->root_visual,
mask, values);
rect = xcb_generate_id (connection);
xcb_create_pixmap (connection, depth,
rect, window,
600, 800);
xcb_map_window(connection, window);
xcb_colormap_t colormap;
colormap = screen->default_colormap;
xcb_alloc_color_reply_t *rep;
rep = xcb_alloc_color_reply (connection, xcb_alloc_color (connection, colormap, 0, 0, 0), NULL);
pal_[0] = rep->pixel;
free(rep);
rep = xcb_alloc_color_reply (connection, xcb_alloc_color (connection, colormap, 0x55<<8, 0x55<<8, 0x55<<8), NULL);
pal_[1] = rep->pixel;
free(rep);
rep = xcb_alloc_color_reply (connection, xcb_alloc_color (connection, colormap, 0xaa<<8, 0xaa<<8, 0xaa<<8), NULL);
pal_[2] = rep->pixel;
free(rep);
rep = xcb_alloc_color_reply (connection, xcb_alloc_color (connection, colormap, 0xff<<8, 0xff<<8, 0xff<<8), NULL);
pal_[3] = rep->pixel;
free(rep);
pal = pal_;
xcb_shm_query_version_reply_t *rep_shm;
rep_shm = xcb_shm_query_version_reply (connection,
xcb_shm_query_version (connection),
NULL);
if(rep_shm) {
xcb_image_format_t format;
int shmctl_status;
if (rep_shm->shared_pixmaps &&
(rep_shm->major_version > 1 || rep_shm->minor_version > 0))
format = (xcb_image_format_t)rep_shm->pixmap_format;
else
format = (xcb_image_format_t)0;
im = xcb_image_create_native (connection, 600, 800,
format, depth, NULL, ~0, NULL);
assert(im);
shminfo.shmid = shmget (IPC_PRIVATE,
im->stride*im->height,
IPC_CREAT | 0777);
assert(shminfo.shmid != -1);
shminfo.shmaddr = (uint8_t*)shmat (shminfo.shmid, 0, 0);
assert(shminfo.shmaddr);
im->data = shminfo.shmaddr;
shminfo.shmseg = xcb_generate_id (connection);
xcb_shm_attach (connection, shminfo.shmseg,
shminfo.shmid, 0);
shmctl_status = shmctl(shminfo.shmid, IPC_RMID, 0);
assert(shmctl_status != -1);
free (rep_shm);
}
xcb_flush(connection);
}
int main(int argc, char *argv[])
{
int screenNumber;
xcb_connection_t *connection = xcb_connect (NULL, &screenNumber); // DISPLAY=NULL -> uses environment DISPLAY
const xcb_setup_t *setup = xcb_get_setup(connection);
xcb_screen_iterator_t iter = xcb_setup_roots_iterator(setup);
for (int i = 0; i < screenNumber; i++) xcb_screen_next(&iter);
xcb_screen_t *screen = iter.data;
xcb_window_t root = screen->root;
xcb_drawable_t window;
uint32_t mask;
uint32_t value[2];
xcb_generic_error_t *error;
xcb_generic_event_t *event;
// color maps
// use existing screen's color map
xcb_colormap_t currentColorMap = screen->default_colormap;
uint16_t colorRed = 255;
// uint16_t colorRed = 65535;
uint16_t colorGreen = 0;
uint16_t colorBlue = 0;
xcb_alloc_color_cookie_t allocColorCookie = xcb_alloc_color(
connection,
currentColorMap,
colorRed,
colorGreen,
colorBlue
);
xcb_alloc_color_reply_t *allocColorReply = xcb_alloc_color_reply(
connection,
allocColorCookie,
&error
);
uint32_t pixel = allocColorReply->pixel;
delete allocColorReply;
// create a window
window = xcb_generate_id(connection); // ask for an ID like in OpenGL
std::string windowTitle = "My first window";
std::string windowTitleIconified = "My first window (iconified)";
mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
value[0] = pixel;
// value[0] = screen->white_pixel;
value[1] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_KEY_RELEASE;
xcb_create_window(connection,
XCB_COPY_FROM_PARENT, // depth same as parent window
window, // create a window using this ID
screen->root, // setting root as parent window
100, 100, // (x,y) offset from top left corner
600, 600, // window's width and height
10, // window's border
XCB_WINDOW_CLASS_INPUT_OUTPUT, // (uint16t) "_class" (TODO: check this out)
screen->root_visual, // (xcb_visualid_t) "visual" (TODO: check this out)
mask, // (uint32t) "value_mask" (TODO: check this out)
value // (const uint32_t) "*value_list" (TODO: check this out)
);
xcb_void_cookie_t changePropertyCookie = xcb_change_property_checked(
connection,
XCB_PROP_MODE_REPLACE,
window,
XCB_ATOM_WM_NAME,
XCB_ATOM_STRING,
8,
windowTitle.size(),
windowTitle.c_str()
);
if ((error = xcb_request_check(connection, changePropertyCookie))) {
std::cerr << "ERROR: trying to change window's property" << std::endl;
delete error;
} else {
std::cout << "changing window's property ....SUCCESS" << std::endl;
}
xcb_window_t window2 = xcb_generate_id(connection); // ask for an ID like in OpenGL
mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
value[0] = screen->white_pixel;
value[1] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_KEY_RELEASE;
xcb_create_window(connection,
XCB_COPY_FROM_PARENT, // depth same as parent window
window2, // create a window using this ID
window, // setting root as parent window
10, 10, // (x,y) offset from top left corner
400, 400, // window's width and height
10, // window's border
XCB_WINDOW_CLASS_INPUT_OUTPUT, // (uint16t) "_class" (TODO: check this out)
screen->root_visual, // (xcb_visualid_t) "visual" (TODO: check this out)
mask, // (uint32t) "value_mask" (TODO: check this out)
value // (const uint32_t) "*value_list" (TODO: check this out)
);
xcb_map_window(connection, window);
xcb_map_window(connection, window2);
xcb_flush(connection);
bool escPressed = false;
bool windowIsMapped = true;
while (!escPressed) {
if ( (event = xcb_poll_for_event(connection)) ) {
// event is NULL if there is no event. if error occurs, erros will have an error status
// std::cout << "before switch..." << std::endl;
switch(event->response_type & ~0x80) {
case XCB_EXPOSE:
{
xcb_expose_event_t *ev = (xcb_expose_event_t *) event;
break;
}
case XCB_BUTTON_PRESS:
{
xcb_button_press_event_t *ev = (xcb_button_press_event_t *) event;
break;
}
case XCB_KEY_RELEASE:
{
xcb_key_release_event_t *ev = (xcb_key_release_event_t *) event;
break;
}
default:
std::cout << "unknown event" <<std::endl;
break;
}
delete event;
}
// std::cout << "after processing events..." << std::endl;
}
// std::cout << "after while true..." << std::endl;
// pause();
// shut down connection
xcb_disconnect(connection);
return 0;
}
static DATA8 *
x_color_alloc_rgb(int nr,
int ng,
int nb,
xcb_connection_t *conn,
xcb_colormap_t cmap,
xcb_visualtype_t *v)
{
int r, g, b, i;
DATA8 *color_lut;
int sig_mask = 0;
int delt = 0;
for (i = 0; i < v->bits_per_rgb_value; i++) sig_mask |= (0x1 << i);
sig_mask <<= (16 - v->bits_per_rgb_value);
i = 0;
color_lut = malloc((nr) * (ng) * (nb));
if (!color_lut) return NULL;
delt = 0x0101 * 3;
/* FIXME: remove the round-trip ? */
for (r = 0; r < (nr); r++)
{
for (g = 0; g < (ng); g++)
{
for (b = 0; b < (nb); b++)
{
xcb_coloritem_t xcl;
xcb_coloritem_t xcl_in;
xcb_alloc_color_reply_t *rep;
int val;
int dr, dg, db;
val = (int)(((r * 255) / ((nr) - 1)));
val = (val << 8) | val;
xcl.red = (uint16_t)(val);
val = (int)(((g * 255) / ((ng) - 1)));
val = (val << 8) | val;
xcl.green = (uint16_t)(val);
val = (int)(((b * 255) / ((nb) - 1)));
val = (val << 8) | val;
xcl.blue = (uint16_t)(val);
xcl_in = xcl;
rep = xcb_alloc_color_reply(conn,
xcb_alloc_color_unchecked(conn,
cmap,
xcl.red,
xcl.green,
xcl.blue),
0);
dr = (int)xcl_in.red - (int)xcl.red;
if (dr < 0) dr = -dr;
dg = (int)xcl_in.green - (int)xcl.green;
if (dg < 0) dg = -dg;
db = (int)xcl_in.blue - (int)xcl.blue;
if (db < 0) db = -db;
/*
printf("ASK [%i]: %04x %04x %04x = %04x %04x %04x | dif = %04x / %04x\n",
ret,
xcl_in.red, xcl_in.green, xcl_in.blue,
xcl.red, xcl.green, xcl.blue,
(dr + dg +db), delt);
*/
/* TODO: XAllocColor tries to approach the color */
/* in case the allocation fails */
/* XCB does not that (i think). It should be done */
/* So if rep == NULL, the other following tests */
/* should be always satisfied */
if ((!rep) ||
((dr + dg + db) > delt)
/*
((xcl_in.red & sig_mask) != (xcl.red & sig_mask)) ||
((xcl_in.green & sig_mask) != (xcl.green & sig_mask)) ||
((xcl_in.blue & sig_mask) != (xcl.blue & sig_mask))
*/
)
{
uint32_t pixels[256];
int j;
if (i > 0)
{
for (j = 0; j < i; j++)
pixels[j] = (uint32_t)color_lut[j];
xcb_free_colors(conn, cmap, 0, i, pixels);
}
free(color_lut);
return NULL;
}
color_lut[i] = rep->pixel;
i++;
free(rep);
}
}
}
return color_lut;
}
static DATA8 *
x_color_alloc_gray(int ng,
xcb_connection_t *conn,
xcb_colormap_t cmap,
xcb_visualtype_t *v)
{
int g, i;
DATA8 *color_lut;
int sig_mask = 0;
for (i = 0; i < v->bits_per_rgb_value; i++) sig_mask |= (0x1 << i);
sig_mask <<= (16 - v->bits_per_rgb_value);
i = 0;
color_lut = malloc(ng);
if (!color_lut) return NULL;
/* FIXME: remove the round-trip ? */
for (g = 0; g < (ng); g++)
{
xcb_coloritem_t xcl;
xcb_coloritem_t xcl_in;
int val;
xcb_alloc_color_reply_t *rep;
val = (int)(((g * 255) / ((ng) - 1)));
val = (val << 8) | val;
xcl.red = (uint16_t)(val);
xcl.green = (uint16_t)(val);
xcl.blue = (uint16_t)(val);
xcl_in = xcl;
rep = xcb_alloc_color_reply(conn,
xcb_alloc_color_unchecked(conn,
cmap,
xcl.red,
xcl.green,
xcl.blue),
0);
/* FIXME: XAllocColor tries to approach the color */
/* in case the allocation fails */
/* XCB does not that (i think). It should be done */
/* So if rep == NULL, the other following tests */
/* should be always satisfied */
if ((!rep) ||
((xcl_in.red & sig_mask) != (xcl.red & sig_mask)) ||
((xcl_in.green & sig_mask) != (xcl.green & sig_mask)) ||
((xcl_in.blue & sig_mask) != (xcl.blue & sig_mask)))
{
uint32_t pixels[256];
int j;
if (i > 0)
{
for (j = 0; j < i; j++)
pixels[j] = (uint32_t) color_lut[j];
xcb_free_colors(conn, cmap, 0, i, pixels);
}
free(color_lut);
return NULL;
}
color_lut[i] = rep->pixel;
i++;
free(rep);
}
return color_lut;
}
void xcbosd_blend(xcbosd *osd, vo_overlay_t *overlay)
{
xcb_alloc_color_cookie_t alloc_color_cookie;
xcb_alloc_color_reply_t *alloc_color_reply;
if (osd->clean==UNDEFINED)
xcbosd_clear(osd); /* Workaround. Colorkey mode needs sc data before the clear. */
if (overlay->rle) {
int i, x, y, len, width;
int use_clip_palette, max_palette_colour[2];
uint32_t palette[2][OVL_PALETTE_SIZE];
max_palette_colour[0] = -1;
max_palette_colour[1] = -1;
for (i=0, x=0, y=0; i<overlay->num_rle; i++) {
len = overlay->rle[i].len;
while (len > 0) {
use_clip_palette = 0;
if (len > overlay->width) {
width = overlay->width;
len -= overlay->width;
}
else {
width = len;
len = 0;
}
if ((y >= overlay->hili_top) && (y <= overlay->hili_bottom) && (x <= overlay->hili_right)) {
if ((x < overlay->hili_left) && (x + width - 1 >= overlay->hili_left)) {
width -= overlay->hili_left - x;
len += overlay->hili_left - x;
}
else if (x > overlay->hili_left) {
use_clip_palette = 1;
if (x + width - 1 > overlay->hili_right) {
width -= overlay->hili_right - x;
len += overlay->hili_right - x;
}
}
}
if (overlay->rle[i].color > max_palette_colour[use_clip_palette]) {
int j;
clut_t *src_clut;
uint8_t *src_trans;
if (use_clip_palette) {
src_clut = (clut_t *)&overlay->hili_color;
src_trans = (uint8_t *)&overlay->hili_trans;
}
else {
src_clut = (clut_t *)&overlay->color;
src_trans = (uint8_t *)&overlay->trans;
}
for (j=max_palette_colour[use_clip_palette]+1; j<=overlay->rle[i].color; j++) {
if (src_trans[j]) {
if (1) {
int red, green, blue;
int y, u, v, r, g, b;
y = saturate(src_clut[j].y, 16, 235);
u = saturate(src_clut[j].cb, 16, 240);
v = saturate(src_clut[j].cr, 16, 240);
y = (9 * y) / 8;
r = y + (25 * v) / 16 - 218;
red = (65536 * saturate(r, 0, 255)) / 256;
g = y + (-13 * v) / 16 + (-25 * u) / 64 + 136;
green = (65536 * saturate(g, 0, 255)) / 256;
b = y + 2 * u - 274;
blue = (65536 * saturate(b, 0, 255)) / 256;
alloc_color_cookie = xcb_alloc_color(osd->connection, osd->cmap, red, green, blue);
alloc_color_reply = xcb_alloc_color_reply(osd->connection, alloc_color_cookie, NULL);
palette[use_clip_palette][j] = alloc_color_reply->pixel;
free(alloc_color_reply);
}
else {
if (src_clut[j].y > 127) {
palette[use_clip_palette][j] = osd->screen->white_pixel;
}
else {
palette[use_clip_palette][j] = osd->screen->black_pixel;
}
}
}
else {
palette[use_clip_palette][j] = TRANSPARENT;
}
}
max_palette_colour[use_clip_palette] = overlay->rle[i].color;
}
if(palette[use_clip_palette][overlay->rle[i].color] != TRANSPARENT) {
xcb_change_gc(osd->connection, osd->gc, XCB_GC_FOREGROUND, &palette[use_clip_palette][overlay->rle[i].color]);
xcb_rectangle_t rectangle = { overlay->x + x, overlay->y + y, width, 1 };
xcb_poly_fill_rectangle(osd->connection, osd->bitmap, osd->gc, 1, &rectangle);
if(osd->mode==XCBOSD_SHAPED)
xcb_poly_fill_rectangle(osd->connection, osd->u.shaped.mask_bitmap, osd->u.shaped.mask_gc, 1, &rectangle);
}
x += width;
if (x == overlay->width) {
x = 0;
y++;
}
}
}
osd->clean = DRAWN;
}
}
