… | |
… | |
729 | return false; |
729 | return false; |
730 | |
730 | |
731 | if (!pixbuf) |
731 | if (!pixbuf) |
732 | return false; |
732 | return false; |
733 | |
733 | |
734 | #if !XFT |
734 | #if !XRENDER |
735 | if (background_flags) |
735 | if (background_flags) |
736 | return false; |
736 | return false; |
737 | #endif |
737 | #endif |
738 | |
738 | |
739 | GdkPixbuf *result; |
739 | GdkPixbuf *result; |
… | |
… | |
856 | dst_width, dst_height, |
856 | dst_width, dst_height, |
857 | XLIB_RGB_DITHER_NONE, |
857 | XLIB_RGB_DITHER_NONE, |
858 | 0, 0); |
858 | 0, 0); |
859 | } |
859 | } |
860 | |
860 | |
861 | #if XFT |
861 | #if XRENDER |
862 | if (background_flags) |
862 | if (background_flags) |
863 | { |
863 | { |
864 | Display *dpy = target->dpy; |
864 | Display *dpy = target->dpy; |
865 | XRenderPictureAttributes pa; |
865 | XRenderPictureAttributes pa; |
866 | |
866 | |
867 | XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, target->display->screen)); |
867 | XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, target->visual); |
868 | Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); |
868 | Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); |
869 | |
869 | |
870 | XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual); |
870 | XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual); |
871 | Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa); |
871 | Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa); |
872 | |
872 | |
… | |
… | |
909 | # endif /* HAVE_PIXBUF */ |
909 | # endif /* HAVE_PIXBUF */ |
910 | |
910 | |
911 | bool |
911 | bool |
912 | bgPixmap_t::set_file (const char *file) |
912 | bgPixmap_t::set_file (const char *file) |
913 | { |
913 | { |
914 | assert (file); |
914 | if (!file || !*file) |
|
|
915 | return false; |
915 | |
916 | |
916 | if (*file) |
|
|
917 | { |
|
|
918 | if (const char *p = strchr (file, ';')) |
917 | if (const char *p = strchr (file, ';')) |
919 | { |
918 | { |
920 | size_t len = p - file; |
919 | size_t len = p - file; |
921 | char *f = rxvt_temp_buf<char> (len + 1); |
920 | char *f = rxvt_temp_buf<char> (len + 1); |
922 | memcpy (f, file, len); |
921 | memcpy (f, file, len); |
923 | f[len] = '\0'; |
922 | f[len] = '\0'; |
924 | file = f; |
923 | file = f; |
925 | } |
924 | } |
926 | |
925 | |
927 | # ifdef HAVE_AFTERIMAGE |
926 | # ifdef HAVE_AFTERIMAGE |
928 | if (!target->asimman) |
927 | if (!target->asimman) |
929 | target->asimman = create_generic_imageman (target->rs[Rs_path]); |
928 | target->asimman = create_generic_imageman (target->rs[Rs_path]); |
930 | ASImage *image = get_asimage (target->asimman, file, 0xFFFFFFFF, 100); |
929 | ASImage *image = get_asimage (target->asimman, file, 0xFFFFFFFF, 100); |
931 | if (image) |
930 | if (image) |
932 | { |
931 | { |
933 | if (original_asim) |
932 | if (original_asim) |
934 | safe_asimage_destroy (original_asim); |
933 | safe_asimage_destroy (original_asim); |
935 | original_asim = image; |
934 | original_asim = image; |
936 | have_image = true; |
935 | have_image = true; |
937 | return true; |
936 | return true; |
938 | } |
937 | } |
939 | # endif |
938 | # endif |
940 | |
939 | |
941 | # ifdef HAVE_PIXBUF |
940 | # ifdef HAVE_PIXBUF |
942 | GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); |
941 | GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL); |
943 | if (image) |
942 | if (image) |
944 | { |
943 | { |
945 | if (pixbuf) |
944 | if (pixbuf) |
946 | g_object_unref (pixbuf); |
945 | g_object_unref (pixbuf); |
947 | pixbuf = image; |
946 | pixbuf = image; |
948 | have_image = true; |
947 | have_image = true; |
949 | return true; |
948 | return true; |
950 | } |
949 | } |
951 | # endif |
950 | # endif |
952 | } |
|
|
953 | |
951 | |
954 | return false; |
952 | return false; |
955 | } |
953 | } |
956 | |
954 | |
957 | # endif /* BG_IMAGE_FROM_FILE */ |
955 | # endif /* BG_IMAGE_FROM_FILE */ |
… | |
… | |
1000 | if (v_blurRadius == 0 && h_blurRadius == 0) |
998 | if (v_blurRadius == 0 && h_blurRadius == 0) |
1001 | flags &= ~blurNeeded; |
999 | flags &= ~blurNeeded; |
1002 | else |
1000 | else |
1003 | flags |= blurNeeded; |
1001 | flags |= blurNeeded; |
1004 | |
1002 | |
1005 | #if XFT |
1003 | #if XRENDER |
1006 | XFilters *filters = XRenderQueryFilters (target->dpy, target->display->root); |
1004 | XFilters *filters = XRenderQueryFilters (target->dpy, target->vt); |
1007 | if (filters) |
1005 | if (filters) |
1008 | { |
1006 | { |
1009 | for (int i = 0; i < filters->nfilter; i++) |
1007 | for (int i = 0; i < filters->nfilter; i++) |
1010 | if (!strcmp (filters->filter[i], FilterConvolution)) |
1008 | if (!strcmp (filters->filter[i], FilterConvolution)) |
1011 | flags |= bgPixmap_t::blurServerSide; |
1009 | flags |= bgPixmap_t::blurServerSide; |
… | |
… | |
1050 | { |
1048 | { |
1051 | if (flags & bgPixmap_t::tintWholesome) |
1049 | if (flags & bgPixmap_t::tintWholesome) |
1052 | flags |= bgPixmap_t::tintServerSide; |
1050 | flags |= bgPixmap_t::tintServerSide; |
1053 | else |
1051 | else |
1054 | { |
1052 | { |
1055 | #if XFT |
1053 | #if XRENDER |
1056 | flags |= bgPixmap_t::tintServerSide; |
1054 | flags |= bgPixmap_t::tintServerSide; |
1057 | #endif |
1055 | #endif |
1058 | } |
1056 | } |
1059 | } |
1057 | } |
1060 | |
1058 | |
… | |
… | |
1107 | } |
1105 | } |
1108 | |
1106 | |
1109 | return false; |
1107 | return false; |
1110 | } |
1108 | } |
1111 | |
1109 | |
1112 | #if XFT |
1110 | #if XRENDER |
1113 | static void |
1111 | static void |
1114 | get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params) |
1112 | get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params) |
1115 | { |
1113 | { |
1116 | double sigma = radius / 2.0; |
1114 | double sigma = radius / 2.0; |
1117 | double scale = sqrt (2.0 * M_PI) * sigma; |
1115 | double scale = sqrt (2.0 * M_PI) * sigma; |
… | |
… | |
1134 | |
1132 | |
1135 | bool |
1133 | bool |
1136 | bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) |
1134 | bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) |
1137 | { |
1135 | { |
1138 | bool ret = false; |
1136 | bool ret = false; |
1139 | #if XFT |
1137 | #if XRENDER |
1140 | int size = max (h_blurRadius, v_blurRadius) * 2 + 1; |
1138 | int size = max (h_blurRadius, v_blurRadius) * 2 + 1; |
1141 | double *kernel = (double *)malloc (size * sizeof (double)); |
1139 | double *kernel = (double *)malloc (size * sizeof (double)); |
1142 | XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); |
1140 | XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); |
1143 | |
1141 | |
1144 | Display *dpy = target->dpy; |
1142 | Display *dpy = target->dpy; |
… | |
… | |
1221 | XFreeGC (dpy, gc); |
1219 | XFreeGC (dpy, gc); |
1222 | } |
1220 | } |
1223 | } |
1221 | } |
1224 | else |
1222 | else |
1225 | { |
1223 | { |
1226 | # if XFT |
1224 | # if XRENDER |
1227 | rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); |
1225 | rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); |
1228 | |
1226 | |
1229 | if (flags & tintSet) |
1227 | if (flags & tintSet) |
1230 | tint.get (c); |
1228 | tint.get (c); |
1231 | |
1229 | |
… | |
… | |
1284 | |
1282 | |
1285 | return ret; |
1283 | return ret; |
1286 | } |
1284 | } |
1287 | |
1285 | |
1288 | /* make_transparency_pixmap() |
1286 | /* make_transparency_pixmap() |
1289 | * Builds a pixmap sized the same as terminal window, with depth same as the root window |
1287 | * Builds a pixmap of the same size as the terminal window that contains |
1290 | * that pixmap contains tiled portion of the root pixmap that is supposed to be covered by |
1288 | * the tiled portion of the root pixmap that is supposed to be covered by |
1291 | * our window. |
1289 | * our window. |
1292 | */ |
1290 | */ |
1293 | unsigned long |
1291 | unsigned long |
1294 | bgPixmap_t::make_transparency_pixmap () |
1292 | bgPixmap_t::make_transparency_pixmap () |
1295 | { |
1293 | { |
… | |
… | |
1299 | return 0; |
1297 | return 0; |
1300 | |
1298 | |
1301 | /* root dimensions may change from call to call - but Display structure should |
1299 | /* root dimensions may change from call to call - but Display structure should |
1302 | * be always up-to-date, so let's use it : |
1300 | * be always up-to-date, so let's use it : |
1303 | */ |
1301 | */ |
1304 | Window root = target->display->root; |
|
|
1305 | int screen = target->display->screen; |
1302 | int screen = target->display->screen; |
1306 | Display *dpy = target->dpy; |
1303 | Display *dpy = target->dpy; |
|
|
1304 | int root_depth = DefaultDepth (dpy, screen); |
1307 | int root_width = DisplayWidth (dpy, screen); |
1305 | int root_width = DisplayWidth (dpy, screen); |
1308 | int root_height = DisplayHeight (dpy, screen); |
1306 | int root_height = DisplayHeight (dpy, screen); |
1309 | unsigned int root_pmap_width, root_pmap_height; |
1307 | unsigned int root_pmap_width, root_pmap_height; |
1310 | int window_width = target->szHint.width; |
1308 | int window_width = target->szHint.width; |
1311 | int window_height = target->szHint.height; |
1309 | int window_height = target->szHint.height; |
… | |
… | |
1318 | /* check if we are outside of the visible part of the virtual screen : */ |
1316 | /* check if we are outside of the visible part of the virtual screen : */ |
1319 | if (sx + window_width <= 0 || sy + window_height <= 0 |
1317 | if (sx + window_width <= 0 || sy + window_height <= 0 |
1320 | || sx >= root_width || sy >= root_height) |
1318 | || sx >= root_width || sy >= root_height) |
1321 | return 0; |
1319 | return 0; |
1322 | |
1320 | |
|
|
1321 | // validate root pixmap and get its size |
1323 | if (root_pixmap != None) |
1322 | if (root_pixmap != None) |
1324 | { |
1323 | { |
1325 | /* we want to validate the pixmap and get its size at the same time : */ |
1324 | Window wdummy; |
1326 | int junk; |
1325 | int idummy; |
1327 | unsigned int ujunk; |
1326 | unsigned int udummy; |
1328 | /* root pixmap may be bad - allow a error */ |
1327 | |
1329 | target->allowedxerror = -1; |
1328 | target->allowedxerror = -1; |
1330 | |
1329 | |
1331 | if (!XGetGeometry (dpy, root_pixmap, &root, &junk, &junk, &root_pmap_width, &root_pmap_height, &ujunk, &ujunk)) |
1330 | if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy)) |
1332 | root_pixmap = None; |
1331 | root_pixmap = None; |
1333 | |
1332 | |
1334 | target->allowedxerror = 0; |
1333 | target->allowedxerror = 0; |
|
|
1334 | } |
|
|
1335 | |
|
|
1336 | Pixmap recoded_root_pmap = root_pixmap; |
|
|
1337 | |
|
|
1338 | if (root_pixmap != None && root_depth != target->depth) |
|
|
1339 | { |
|
|
1340 | #if XRENDER |
|
|
1341 | XRenderPictureAttributes pa; |
|
|
1342 | |
|
|
1343 | XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen)); |
|
|
1344 | Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa); |
|
|
1345 | |
|
|
1346 | recoded_root_pmap = XCreatePixmap (dpy, target->vt, root_pmap_width, root_pmap_height, target->depth); |
|
|
1347 | XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual); |
|
|
1348 | Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa); |
|
|
1349 | |
|
|
1350 | if (src && dst) |
|
|
1351 | XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height); |
|
|
1352 | else |
|
|
1353 | { |
|
|
1354 | XFreePixmap (dpy, recoded_root_pmap); |
|
|
1355 | root_pixmap = None; |
|
|
1356 | } |
|
|
1357 | |
|
|
1358 | XRenderFreePicture (dpy, src); |
|
|
1359 | XRenderFreePicture (dpy, dst); |
|
|
1360 | #else |
|
|
1361 | root_pixmap = None; |
|
|
1362 | #endif |
1335 | } |
1363 | } |
1336 | |
1364 | |
1337 | if (root_pixmap == None) |
1365 | if (root_pixmap == None) |
1338 | return 0; |
1366 | return 0; |
1339 | |
1367 | |
1340 | Pixmap tiled_root_pmap = XCreatePixmap (dpy, root, window_width, window_height, root_depth); |
1368 | Pixmap tiled_root_pmap = XCreatePixmap (dpy, target->vt, window_width, window_height, target->depth); |
1341 | |
1369 | |
1342 | if (tiled_root_pmap == None) /* something really bad happened - abort */ |
1370 | if (tiled_root_pmap == None) /* something really bad happened - abort */ |
1343 | return 0; |
1371 | return 0; |
1344 | |
1372 | |
1345 | /* straightforward pixmap copy */ |
1373 | /* straightforward pixmap copy */ |
1346 | gcv.tile = root_pixmap; |
1374 | gcv.tile = recoded_root_pmap; |
1347 | gcv.fill_style = FillTiled; |
1375 | gcv.fill_style = FillTiled; |
1348 | |
1376 | |
1349 | while (sx < 0) sx += (int)root_width; |
1377 | while (sx < 0) sx += (int)root_width; |
1350 | while (sy < 0) sy += (int)root_height; |
1378 | while (sy < 0) sy += (int)root_height; |
1351 | |
1379 | |
1352 | gcv.ts_x_origin = -sx; |
1380 | gcv.ts_x_origin = -sx; |
1353 | gcv.ts_y_origin = -sy; |
1381 | gcv.ts_y_origin = -sy; |
1354 | gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); |
1382 | gc = XCreateGC (dpy, target->vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); |
1355 | |
1383 | |
1356 | if (gc) |
1384 | if (gc) |
1357 | { |
1385 | { |
1358 | XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height); |
1386 | XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height); |
1359 | result |= transpPmapTiled; |
1387 | result |= transpPmapTiled; |
… | |
… | |
1362 | |
1390 | |
1363 | if (tiled_root_pmap != None) |
1391 | if (tiled_root_pmap != None) |
1364 | { |
1392 | { |
1365 | if (!need_client_side_rendering ()) |
1393 | if (!need_client_side_rendering ()) |
1366 | { |
1394 | { |
1367 | if (flags & (blurNeeded | blurServerSide)) |
1395 | if ((flags & blurNeeded) |
|
|
1396 | && (flags & blurServerSide)) |
1368 | { |
1397 | { |
1369 | if (blur_pixmap (tiled_root_pmap, DefaultVisual (dpy, screen), window_width, window_height)) |
1398 | if (blur_pixmap (tiled_root_pmap, target->visual, window_width, window_height)) |
1370 | result |= transpPmapBlurred; |
1399 | result |= transpPmapBlurred; |
1371 | } |
1400 | } |
1372 | if (flags & (tintNeeded | tintServerSide)) |
1401 | if ((flags & tintNeeded) |
|
|
1402 | && (flags & tintServerSide)) |
1373 | { |
1403 | { |
1374 | if (tint_pixmap (tiled_root_pmap, DefaultVisual (dpy, screen), window_width, window_height)) |
1404 | if (tint_pixmap (tiled_root_pmap, target->visual, window_width, window_height)) |
1375 | result |= transpPmapTinted; |
1405 | result |= transpPmapTinted; |
1376 | } |
1406 | } |
1377 | } /* server side rendering completed */ |
1407 | } /* server side rendering completed */ |
1378 | |
1408 | |
1379 | if (pixmap) |
1409 | if (pixmap) |
1380 | XFreePixmap (dpy, pixmap); |
1410 | XFreePixmap (dpy, pixmap); |
1381 | |
1411 | |
1382 | pixmap = tiled_root_pmap; |
1412 | pixmap = tiled_root_pmap; |
1383 | pmap_width = window_width; |
1413 | pmap_width = window_width; |
1384 | pmap_height = window_height; |
1414 | pmap_height = window_height; |
1385 | pmap_depth = root_depth; |
1415 | pmap_depth = target->depth; |
1386 | } |
1416 | } |
|
|
1417 | |
|
|
1418 | if (recoded_root_pmap != root_pixmap) |
|
|
1419 | XFreePixmap (dpy, recoded_root_pmap); |
1387 | |
1420 | |
1388 | return result; |
1421 | return result; |
1389 | } |
1422 | } |
1390 | |
1423 | |
1391 | bool |
1424 | void |
1392 | bgPixmap_t::set_root_pixmap () |
1425 | bgPixmap_t::set_root_pixmap () |
1393 | { |
1426 | { |
1394 | Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID); |
1427 | Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID); |
1395 | if (new_root_pixmap == None) |
1428 | if (new_root_pixmap == None) |
1396 | new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID); |
1429 | new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID); |
1397 | |
1430 | |
1398 | if (new_root_pixmap != root_pixmap) |
|
|
1399 | { |
|
|
1400 | root_pixmap = new_root_pixmap; |
1431 | root_pixmap = new_root_pixmap; |
1401 | return true; |
|
|
1402 | } |
|
|
1403 | |
|
|
1404 | return false; |
|
|
1405 | } |
1432 | } |
1406 | # endif /* ENABLE_TRANSPARENCY */ |
1433 | # endif /* ENABLE_TRANSPARENCY */ |
1407 | |
1434 | |
1408 | # ifndef HAVE_AFTERIMAGE |
1435 | # ifndef HAVE_AFTERIMAGE |
1409 | static void ShadeXImage(Visual *visual, XImage *srcImage, int shade, int rm, int gm, int bm); |
1436 | static void ShadeXImage(Visual *visual, XImage *srcImage, int shade, int rm, int gm, int bm); |
… | |
… | |
1423 | { |
1450 | { |
1424 | /* we need to re-generate transparency pixmap in that case ! */ |
1451 | /* we need to re-generate transparency pixmap in that case ! */ |
1425 | background_flags = make_transparency_pixmap (); |
1452 | background_flags = make_transparency_pixmap (); |
1426 | if (background_flags == 0) |
1453 | if (background_flags == 0) |
1427 | return false; |
1454 | return false; |
1428 | else if ((background_flags & transpTransformations) == (flags & transpTransformations) |
1455 | else if ((background_flags & transpTransformations) == (flags & transpTransformations)) |
1429 | && pmap_depth == target->depth) |
|
|
1430 | flags = flags & ~isInvalid; |
1456 | flags = flags & ~isInvalid; |
1431 | } |
1457 | } |
1432 | # endif |
1458 | # endif |
1433 | |
1459 | |
1434 | # ifdef BG_IMAGE_FROM_FILE |
1460 | # ifdef BG_IMAGE_FROM_FILE |
… | |
… | |
1447 | result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap); |
1473 | result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap); |
1448 | } |
1474 | } |
1449 | |
1475 | |
1450 | if (result) |
1476 | if (result) |
1451 | { |
1477 | { |
1452 | # if !defined(HAVE_AFTERIMAGE) && !XFT |
1478 | # if !defined(HAVE_AFTERIMAGE) && !XRENDER |
1453 | /* our own client-side tinting */ |
1479 | /* our own client-side tinting */ |
1454 | /* ATTENTION: We ASSUME that XFT will let us do all the tinting necessary server-side. |
|
|
1455 | This may need to be changed in need_client_side_rendering() logic is altered !!! */ |
|
|
1456 | if (!(background_flags & transpPmapTinted) && (flags & tintNeeded)) |
1480 | if (!(background_flags & transpPmapTinted) && (flags & tintNeeded)) |
1457 | { |
1481 | { |
1458 | rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); |
1482 | rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); |
1459 | if (flags & tintSet) |
1483 | if (flags & tintSet) |
1460 | tint.get (c); |
1484 | tint.get (c); |
… | |
… | |
1464 | |
1488 | |
1465 | GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL); |
1489 | GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL); |
1466 | |
1490 | |
1467 | if (gc) |
1491 | if (gc) |
1468 | { |
1492 | { |
1469 | if (/*pmap_depth != target->depth &&*/ pixmap != None) |
|
|
1470 | { |
|
|
1471 | XFreePixmap (target->dpy, pixmap); |
|
|
1472 | pixmap = None; |
|
|
1473 | } |
|
|
1474 | |
|
|
1475 | if (pixmap == None) |
|
|
1476 | { |
|
|
1477 | pixmap = XCreatePixmap (target->dpy, target->vt, result->width, result->height, target->depth); |
|
|
1478 | pmap_width = result->width; |
|
|
1479 | pmap_height = result->height; |
|
|
1480 | pmap_depth = target->depth; |
|
|
1481 | } |
|
|
1482 | |
|
|
1483 | if (pmap_depth != result->depth) |
|
|
1484 | { |
|
|
1485 | /* Bad Match error will ensue ! stupid X !!!! */ |
|
|
1486 | if (result->depth == 24 && pmap_depth == 32) |
|
|
1487 | result->depth = 32; |
|
|
1488 | else if (result->depth == 32 && pmap_depth == 24) |
|
|
1489 | result->depth = 24; |
|
|
1490 | else |
|
|
1491 | { |
|
|
1492 | /* TODO: implement image recoding */ |
|
|
1493 | } |
|
|
1494 | } |
|
|
1495 | |
|
|
1496 | if (pmap_depth == result->depth) |
|
|
1497 | XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height); |
1493 | XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height); |
1498 | |
1494 | |
1499 | XFreeGC (target->dpy, gc); |
1495 | XFreeGC (target->dpy, gc); |
1500 | flags = flags & ~isInvalid; |
1496 | flags = flags & ~isInvalid; |
1501 | } |
1497 | } |
1502 | |
1498 | |
… | |
… | |
1517 | valid_since = ev::now (); |
1513 | valid_since = ev::now (); |
1518 | |
1514 | |
1519 | return true; |
1515 | return true; |
1520 | } |
1516 | } |
1521 | |
1517 | |
1522 | bool |
1518 | void |
1523 | bgPixmap_t::set_target (rxvt_term *new_target) |
1519 | bgPixmap_t::set_target (rxvt_term *new_target) |
1524 | { |
1520 | { |
1525 | if (new_target) |
|
|
1526 | if (target != new_target) |
|
|
1527 | { |
|
|
1528 | target = new_target; |
1521 | target = new_target; |
1529 | # ifdef ENABLE_TRANSPARENCY |
|
|
1530 | root_depth = DefaultDepthOfScreen (ScreenOfDisplay (target->dpy, target->display->screen)); |
|
|
1531 | # endif |
|
|
1532 | return true; |
|
|
1533 | } |
|
|
1534 | |
|
|
1535 | return false; |
|
|
1536 | } |
1522 | } |
1537 | |
1523 | |
1538 | void |
1524 | void |
1539 | bgPixmap_t::apply () |
1525 | bgPixmap_t::apply () |
1540 | { |
1526 | { |
1541 | if (target) |
1527 | if (target == NULL) |
1542 | { |
1528 | return; |
|
|
1529 | |
1543 | if (pixmap != None) |
1530 | if (pixmap != None) |
1544 | { |
1531 | { |
1545 | /* set target's background to pixmap */ |
1532 | /* set target's background to pixmap */ |
1546 | # ifdef ENABLE_TRANSPARENCY |
1533 | # ifdef ENABLE_TRANSPARENCY |
1547 | if (flags & isTransparent) |
1534 | if (flags & isTransparent) |
1548 | { |
1535 | { |
1549 | XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap); |
1536 | XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap); |
1550 | XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative); |
1537 | XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative); |
1551 | |
1538 | |
1552 | if (target->scrollBar.win) |
1539 | if (target->scrollBar.win) |
1553 | XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative); |
1540 | XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative); |
1554 | } |
1541 | } |
1555 | else |
1542 | else |
1556 | # endif |
1543 | # endif |
1557 | { |
1544 | { |
1558 | /* force old pixmap dereference in case it was transparent before :*/ |
1545 | /* force old pixmap dereference in case it was transparent before :*/ |
1559 | XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]); |
|
|
1560 | XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap); |
|
|
1561 | /* do we also need to set scrollbar's background here ? */ |
|
|
1562 | |
|
|
1563 | if (target->scrollBar.win) |
|
|
1564 | XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]); |
|
|
1565 | } |
|
|
1566 | } |
|
|
1567 | else |
|
|
1568 | { |
|
|
1569 | /* set target background to a pixel */ |
|
|
1570 | XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]); |
1546 | XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]); |
1571 | XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]); |
1547 | XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap); |
1572 | /* do we also need to set scrollbar's background here ? */ |
1548 | /* do we also need to set scrollbar's background here ? */ |
|
|
1549 | |
1573 | if (target->scrollBar.win) |
1550 | if (target->scrollBar.win) |
1574 | XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]); |
1551 | XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]); |
1575 | } |
1552 | } |
|
|
1553 | } |
|
|
1554 | else |
|
|
1555 | { |
|
|
1556 | /* set target background to a pixel */ |
|
|
1557 | XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]); |
|
|
1558 | XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]); |
|
|
1559 | /* do we also need to set scrollbar's background here ? */ |
|
|
1560 | if (target->scrollBar.win) |
|
|
1561 | XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]); |
|
|
1562 | } |
1576 | |
1563 | |
1577 | /* don't want Expose on the parent or vt. It is better to use |
1564 | /* don't want Expose on the parent or vt. It is better to use |
1578 | scr_touch or we get a great deal of flicker otherwise: */ |
1565 | scr_touch or we get a great deal of flicker otherwise: */ |
1579 | XClearWindow (target->dpy, target->parent[0]); |
1566 | XClearWindow (target->dpy, target->parent[0]); |
1580 | |
1567 | |
1581 | if (target->scrollBar.state && target->scrollBar.win) |
1568 | if (target->scrollBar.state && target->scrollBar.win) |
1582 | { |
1569 | { |
1583 | target->scrollBar.state = STATE_IDLE; |
1570 | target->scrollBar.state = STATE_IDLE; |
1584 | target->scrollBar.show (0); |
1571 | target->scrollBar.show (0); |
1585 | } |
1572 | } |
1586 | |
1573 | |
1587 | target->want_refresh = 1; |
1574 | target->want_refresh = 1; |
1588 | flags |= hasChanged; |
1575 | flags |= hasChanged; |
1589 | } |
|
|
1590 | } |
1576 | } |
1591 | |
1577 | |
1592 | #endif /* HAVE_BG_PIXMAP */ |
1578 | #endif /* HAVE_BG_PIXMAP */ |
1593 | |
1579 | |
1594 | #if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XFT |
1580 | #if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XRENDER |
1595 | /* taken from aterm-0.4.2 */ |
1581 | /* taken from aterm-0.4.2 */ |
1596 | |
1582 | |
1597 | static void |
1583 | static void |
1598 | ShadeXImage(Visual *visual, XImage *srcImage, int shade, int rm, int gm, int bm) |
1584 | ShadeXImage(Visual *visual, XImage *srcImage, int shade, int rm, int gm, int bm) |
1599 | { |
1585 | { |