ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/background.C
(Generate patch)

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.94 by sf-exg, Wed Oct 20 09:04:55 2010 UTC vs.
Revision 1.103 by sf-exg, Sun Oct 31 11:15:29 2010 UTC

… …
428 { 428 {
429 flags = new_flags; 429 flags = new_flags;
430 changed++; 430 changed++;
431 } 431 }
432 432
433 //fprintf (stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
434 // flags, h_scale, v_scale, h_align, v_align);
435 return (changed > 0); 433 return (changed > 0);
436} 434}
437 435
438void 436void
439bgPixmap_t::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y) 437bgPixmap_t::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
… …
529 527
530 int x = 0; 528 int x = 0;
531 int y = 0; 529 int y = 0;
532 int w = 0; 530 int w = 0;
533 int h = 0; 531 int h = 0;
534
535 TIMING_TEST_START (asim);
536 532
537 if (original_asim) 533 if (original_asim)
538 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y); 534 get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
539 535
540 if (!original_asim 536 if (!original_asim
… …
657 } 653 }
658 654
659 free (layers); 655 free (layers);
660 } 656 }
661 } 657 }
662 TIMING_TEST_PRINT_RESULT (asim);
663 658
664 bool ret = false; 659 bool ret = false;
665 660
666 if (result) 661 if (result)
667 { 662 {
… …
713 708
714 if (result != background && result != original_asim) 709 if (result != background && result != original_asim)
715 destroy_asimage (&result); 710 destroy_asimage (&result);
716 711
717 XFreeGC (target->dpy, gc); 712 XFreeGC (target->dpy, gc);
718 TIMING_TEST_PRINT_RESULT (asim);
719 713
720 ret = true; 714 ret = true;
721 } 715 }
722 716
723 if (background) 717 if (background)
… …
735 return false; 729 return false;
736 730
737 if (!pixbuf) 731 if (!pixbuf)
738 return false; 732 return false;
739 733
740#if !XFT 734#if !XRENDER
741 if (background_flags) 735 if (background_flags)
742 return false; 736 return false;
743#endif 737#endif
744 738
745 GdkPixbuf *result; 739 GdkPixbuf *result;
… …
862 dst_width, dst_height, 856 dst_width, dst_height,
863 XLIB_RGB_DITHER_NONE, 857 XLIB_RGB_DITHER_NONE,
864 0, 0); 858 0, 0);
865 } 859 }
866 860
867#if XFT 861#if XRENDER
868 if (background_flags) 862 if (background_flags)
869 { 863 {
870 Display *dpy = target->dpy; 864 Display *dpy = target->dpy;
871 XRenderPictureAttributes pa; 865 XRenderPictureAttributes pa;
872 866
873 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, target->display->screen)); 867 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, target->visual);
874 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa); 868 Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);
875 869
876 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual); 870 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
877 Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa); 871 Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa);
878 872
… …
1006 if (v_blurRadius == 0 && h_blurRadius == 0) 1000 if (v_blurRadius == 0 && h_blurRadius == 0)
1007 flags &= ~blurNeeded; 1001 flags &= ~blurNeeded;
1008 else 1002 else
1009 flags |= blurNeeded; 1003 flags |= blurNeeded;
1010 1004
1011#if XFT 1005#if XRENDER
1012 XFilters *filters = XRenderQueryFilters (target->dpy, target->display->root); 1006 XFilters *filters = XRenderQueryFilters (target->dpy, target->vt);
1013 if (filters) 1007 if (filters)
1014 { 1008 {
1015 for (int i = 0; i < filters->nfilter; i++) 1009 for (int i = 0; i < filters->nfilter; i++)
1016 if (!strcmp (filters->filter[i], FilterConvolution)) 1010 if (!strcmp (filters->filter[i], FilterConvolution))
1017 flags |= bgPixmap_t::blurServerSide; 1011 flags |= bgPixmap_t::blurServerSide;
… …
1056 { 1050 {
1057 if (flags & bgPixmap_t::tintWholesome) 1051 if (flags & bgPixmap_t::tintWholesome)
1058 flags |= bgPixmap_t::tintServerSide; 1052 flags |= bgPixmap_t::tintServerSide;
1059 else 1053 else
1060 { 1054 {
1061#if XFT 1055#if XRENDER
1062 flags |= bgPixmap_t::tintServerSide; 1056 flags |= bgPixmap_t::tintServerSide;
1063#endif 1057#endif
1064 } 1058 }
1065 } 1059 }
1066 1060
… …
1113 } 1107 }
1114 1108
1115 return false; 1109 return false;
1116} 1110}
1117 1111
1118#if XFT 1112#if XRENDER
1119static void 1113static void
1120get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params) 1114get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params)
1121{ 1115{
1122 double sigma = radius / 2.0; 1116 double sigma = radius / 2.0;
1123 double scale = sqrt (2.0 * M_PI) * sigma; 1117 double scale = sqrt (2.0 * M_PI) * sigma;
… …
1140 1134
1141bool 1135bool
1142bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height) 1136bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1143{ 1137{
1144 bool ret = false; 1138 bool ret = false;
1145#if XFT 1139#if XRENDER
1146 int size = max (h_blurRadius, v_blurRadius) * 2 + 1; 1140 int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1147 double *kernel = (double *)malloc (size * sizeof (double)); 1141 double *kernel = (double *)malloc (size * sizeof (double));
1148 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 1142 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1149 1143
1150 Display *dpy = target->dpy; 1144 Display *dpy = target->dpy;
… …
1227 XFreeGC (dpy, gc); 1221 XFreeGC (dpy, gc);
1228 } 1222 }
1229 } 1223 }
1230 else 1224 else
1231 { 1225 {
1232# if XFT 1226# if XRENDER
1233 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 1227 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1234 1228
1235 if (flags & tintSet) 1229 if (flags & tintSet)
1236 tint.get (c); 1230 tint.get (c);
1237 1231
… …
1283 } 1277 }
1284 1278
1285 XRenderFreePicture (dpy, mask_pic); 1279 XRenderFreePicture (dpy, mask_pic);
1286 XRenderFreePicture (dpy, overlay_pic); 1280 XRenderFreePicture (dpy, overlay_pic);
1287 XRenderFreePicture (dpy, back_pic); 1281 XRenderFreePicture (dpy, back_pic);
1288# if DO_TIMING_TEST
1289 XSync (dpy, False);
1290# endif
1291# endif 1282# endif
1292 } 1283 }
1293 1284
1294 return ret; 1285 return ret;
1295} 1286}
1296 1287
1297/* make_transparency_pixmap() 1288/* make_transparency_pixmap()
1298 * Builds a pixmap sized the same as terminal window, with depth same as the root window 1289 * Builds a pixmap of the same size as the terminal window that contains
1299 * that pixmap contains tiled portion of the root pixmap that is supposed to be covered by 1290 * the tiled portion of the root pixmap that is supposed to be covered by
1300 * our window. 1291 * our window.
1301 */ 1292 */
1302unsigned long 1293unsigned long
1303bgPixmap_t::make_transparency_pixmap () 1294bgPixmap_t::make_transparency_pixmap ()
1304{ 1295{
… …
1308 return 0; 1299 return 0;
1309 1300
1310 /* root dimensions may change from call to call - but Display structure should 1301 /* root dimensions may change from call to call - but Display structure should
1311 * be always up-to-date, so let's use it : 1302 * be always up-to-date, so let's use it :
1312 */ 1303 */
1313 Window root = target->display->root;
1314 int screen = target->display->screen; 1304 int screen = target->display->screen;
1315 Display *dpy = target->dpy; 1305 Display *dpy = target->dpy;
1306 int root_depth = DefaultDepth (dpy, screen);
1316 int root_width = DisplayWidth (dpy, screen); 1307 int root_width = DisplayWidth (dpy, screen);
1317 int root_height = DisplayHeight (dpy, screen); 1308 int root_height = DisplayHeight (dpy, screen);
1318 unsigned int root_pmap_width, root_pmap_height; 1309 unsigned int root_pmap_width, root_pmap_height;
1319 int window_width = target->szHint.width; 1310 int window_width = target->szHint.width;
1320 int window_height = target->szHint.height; 1311 int window_height = target->szHint.height;
1321 int sx, sy; 1312 int sx, sy;
1322 XGCValues gcv; 1313 XGCValues gcv;
1323 GC gc; 1314 GC gc;
1324 1315
1325 TIMING_TEST_START (tp);
1326 target->get_window_origin (sx, sy); 1316 target->get_window_origin (sx, sy);
1327 1317
1328 /* check if we are outside of the visible part of the virtual screen : */ 1318 /* check if we are outside of the visible part of the virtual screen : */
1329 if (sx + window_width <= 0 || sy + window_height <= 0 1319 if (sx + window_width <= 0 || sy + window_height <= 0
1330 || sx >= root_width || sy >= root_height) 1320 || sx >= root_width || sy >= root_height)
1331 return 0; 1321 return 0;
1332 1322
1323 // validate root pixmap and get its size
1333 if (root_pixmap != None) 1324 if (root_pixmap != None)
1334 { 1325 {
1335 /* we want to validate the pixmap and get its size at the same time : */ 1326 Window wdummy;
1336 int junk; 1327 int idummy;
1337 unsigned int ujunk; 1328 unsigned int udummy;
1338 /* root pixmap may be bad - allow a error */ 1329
1339 target->allowedxerror = -1; 1330 target->allowedxerror = -1;
1340 1331
1341 if (!XGetGeometry (dpy, root_pixmap, &root, &junk, &junk, &root_pmap_width, &root_pmap_height, &ujunk, &ujunk)) 1332 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))
1342 root_pixmap = None; 1333 root_pixmap = None;
1343 1334
1344 target->allowedxerror = 0; 1335 target->allowedxerror = 0;
1336 }
1337
1338 Pixmap recoded_root_pmap = root_pixmap;
1339
1340 if (root_pixmap != None && root_depth != target->depth)
1341 {
1342#if XRENDER
1343 XRenderPictureAttributes pa;
1344
1345 XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1346 Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);
1347
1348 recoded_root_pmap = XCreatePixmap (dpy, target->vt, root_pmap_width, root_pmap_height, target->depth);
1349 XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
1350 Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);
1351
1352 if (src && dst)
1353 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1354 else
1355 root_pixmap = None;
1356
1357 XRenderFreePicture (dpy, src);
1358 XRenderFreePicture (dpy, dst);
1359#else
1360 root_pixmap = None;
1361#endif
1345 } 1362 }
1346 1363
1347 if (root_pixmap == None) 1364 if (root_pixmap == None)
1348 return 0; 1365 return 0;
1349 1366
1350 Pixmap tiled_root_pmap = XCreatePixmap (dpy, root, window_width, window_height, root_depth); 1367 Pixmap tiled_root_pmap = XCreatePixmap (dpy, target->vt, window_width, window_height, target->depth);
1351 1368
1352 if (tiled_root_pmap == None) /* something really bad happened - abort */ 1369 if (tiled_root_pmap == None) /* something really bad happened - abort */
1353 return 0; 1370 return 0;
1354 1371
1355 /* straightforward pixmap copy */ 1372 /* straightforward pixmap copy */
1356 gcv.tile = root_pixmap; 1373 gcv.tile = recoded_root_pmap;
1357 gcv.fill_style = FillTiled; 1374 gcv.fill_style = FillTiled;
1358 1375
1359 while (sx < 0) sx += (int)root_width; 1376 while (sx < 0) sx += (int)root_width;
1360 while (sy < 0) sy += (int)root_height; 1377 while (sy < 0) sy += (int)root_height;
1361 1378
1362 gcv.ts_x_origin = -sx; 1379 gcv.ts_x_origin = -sx;
1363 gcv.ts_y_origin = -sy; 1380 gcv.ts_y_origin = -sy;
1364 gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv); 1381 gc = XCreateGC (dpy, target->vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1365 1382
1366 if (gc) 1383 if (gc)
1367 { 1384 {
1368 XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height); 1385 XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
1369 result |= transpPmapTiled; 1386 result |= transpPmapTiled;
1370 XFreeGC (dpy, gc); 1387 XFreeGC (dpy, gc);
1371 } 1388 }
1372 TIMING_TEST_PRINT_RESULT (tp);
1373 1389
1374 if (tiled_root_pmap != None) 1390 if (tiled_root_pmap != None)
1375 { 1391 {
1376 if (!need_client_side_rendering ()) 1392 if (!need_client_side_rendering ())
1377 { 1393 {
1378 if (flags & (blurNeeded | blurServerSide)) 1394 if (flags & (blurNeeded | blurServerSide))
1379 { 1395 {
1380 if (blur_pixmap (tiled_root_pmap, DefaultVisual (dpy, screen), window_width, window_height)) 1396 if (blur_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1381 result |= transpPmapBlurred; 1397 result |= transpPmapBlurred;
1382 } 1398 }
1383 if (flags & (tintNeeded | tintServerSide)) 1399 if (flags & (tintNeeded | tintServerSide))
1384 { 1400 {
1385 if (tint_pixmap (tiled_root_pmap, DefaultVisual (dpy, screen), window_width, window_height)) 1401 if (tint_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1386 result |= transpPmapTinted; 1402 result |= transpPmapTinted;
1387 } 1403 }
1388 } /* server side rendering completed */ 1404 } /* server side rendering completed */
1389 1405
1390 if (pixmap) 1406 if (pixmap)
1391 XFreePixmap (dpy, pixmap); 1407 XFreePixmap (dpy, pixmap);
1392 1408
1393 pixmap = tiled_root_pmap; 1409 pixmap = tiled_root_pmap;
1394 pmap_width = window_width; 1410 pmap_width = window_width;
1395 pmap_height = window_height; 1411 pmap_height = window_height;
1396 pmap_depth = root_depth; 1412 pmap_depth = target->depth;
1397 } 1413 }
1398 1414
1399 TIMING_TEST_PRINT_RESULT (tp); 1415 if (recoded_root_pmap != root_pixmap)
1416 XFreePixmap (dpy, recoded_root_pmap);
1400 1417
1401 return result; 1418 return result;
1402} 1419}
1403 1420
1404bool 1421void
1405bgPixmap_t::set_root_pixmap () 1422bgPixmap_t::set_root_pixmap ()
1406{ 1423{
1407 Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID); 1424 Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);
1408 if (new_root_pixmap == None) 1425 if (new_root_pixmap == None)
1409 new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID); 1426 new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);
1410 1427
1411 if (new_root_pixmap != root_pixmap)
1412 {
1413 root_pixmap = new_root_pixmap; 1428 root_pixmap = new_root_pixmap;
1414 return true;
1415 }
1416
1417 return false;
1418} 1429}
1419# endif /* ENABLE_TRANSPARENCY */ 1430# endif /* ENABLE_TRANSPARENCY */
1420 1431
1421# ifndef HAVE_AFTERIMAGE 1432# ifndef HAVE_AFTERIMAGE
1422static void ShadeXImage(Visual *visual, XImage *srcImage, int shade, int rm, int gm, int bm); 1433static void ShadeXImage(Visual *visual, XImage *srcImage, int shade, int rm, int gm, int bm);
… …
1427{ 1438{
1428 unsigned long background_flags = 0; 1439 unsigned long background_flags = 0;
1429 1440
1430 if (target == NULL) 1441 if (target == NULL)
1431 return false; 1442 return false;
1432
1433 TIMING_TEST_START (tp);
1434 1443
1435 invalidate (); 1444 invalidate ();
1436# ifdef ENABLE_TRANSPARENCY 1445# ifdef ENABLE_TRANSPARENCY
1437 if (flags & isTransparent) 1446 if (flags & isTransparent)
1438 { 1447 {
1439 /* we need to re-generate transparency pixmap in that case ! */ 1448 /* we need to re-generate transparency pixmap in that case ! */
1440 background_flags = make_transparency_pixmap (); 1449 background_flags = make_transparency_pixmap ();
1441 if (background_flags == 0) 1450 if (background_flags == 0)
1442 return false; 1451 return false;
1443 else if ((background_flags & transpTransformations) == (flags & transpTransformations) 1452 else if ((background_flags & transpTransformations) == (flags & transpTransformations))
1444 && pmap_depth == target->depth)
1445 flags = flags & ~isInvalid; 1453 flags = flags & ~isInvalid;
1446 } 1454 }
1447# endif 1455# endif
1448 1456
1449# ifdef BG_IMAGE_FROM_FILE 1457# ifdef BG_IMAGE_FROM_FILE
… …
1462 result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap); 1470 result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1463 } 1471 }
1464 1472
1465 if (result) 1473 if (result)
1466 { 1474 {
1467# if !defined(HAVE_AFTERIMAGE) && !XFT 1475# if !defined(HAVE_AFTERIMAGE) && !XRENDER
1468 /* our own client-side tinting */ 1476 /* our own client-side tinting */
1469 /* ATTENTION: We ASSUME that XFT will let us do all the tinting necessary server-side.
1470 This may need to be changed in need_client_side_rendering() logic is altered !!! */
1471 if (!(background_flags & transpPmapTinted) && (flags & tintNeeded)) 1477 if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1472 { 1478 {
1473 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC); 1479 rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1474 if (flags & tintSet) 1480 if (flags & tintSet)
1475 tint.get (c); 1481 tint.get (c);
… …
1479 1485
1480 GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL); 1486 GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1481 1487
1482 if (gc) 1488 if (gc)
1483 { 1489 {
1484 if (/*pmap_depth != target->depth &&*/ pixmap != None)
1485 {
1486 XFreePixmap (target->dpy, pixmap);
1487 pixmap = None;
1488 }
1489
1490 if (pixmap == None)
1491 {
1492 pixmap = XCreatePixmap (target->dpy, target->vt, result->width, result->height, target->depth);
1493 pmap_width = result->width;
1494 pmap_height = result->height;
1495 pmap_depth = target->depth;
1496 }
1497
1498 if (pmap_depth != result->depth)
1499 {
1500 /* Bad Match error will ensue ! stupid X !!!! */
1501 if (result->depth == 24 && pmap_depth == 32)
1502 result->depth = 32;
1503 else if (result->depth == 32 && pmap_depth == 24)
1504 result->depth = 24;
1505 else
1506 {
1507 /* TODO: implement image recoding */
1508 }
1509 }
1510
1511 if (pmap_depth == result->depth)
1512 XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height); 1490 XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1513 1491
1514 XFreeGC (target->dpy, gc); 1492 XFreeGC (target->dpy, gc);
1515 flags = flags & ~isInvalid; 1493 flags = flags & ~isInvalid;
1516 } 1494 }
1517 1495
… …
1527 } 1505 }
1528 } 1506 }
1529 1507
1530 apply (); 1508 apply ();
1531 1509
1532 XSync (target->dpy, False);
1533 valid_since = ev::now (); 1510 valid_since = ev::now ();
1534
1535 TIMING_TEST_PRINT_RESULT (tp);
1536 1511
1537 return true; 1512 return true;
1538} 1513}
1539 1514
1540bool 1515bool
… …
1542{ 1517{
1543 if (new_target) 1518 if (new_target)
1544 if (target != new_target) 1519 if (target != new_target)
1545 { 1520 {
1546 target = new_target; 1521 target = new_target;
1547# ifdef ENABLE_TRANSPARENCY
1548 root_depth = DefaultDepthOfScreen (ScreenOfDisplay (target->dpy, target->display->screen));
1549# endif
1550 return true; 1522 return true;
1551 } 1523 }
1552 1524
1553 return false; 1525 return false;
1554} 1526}
… …
1556void 1528void
1557bgPixmap_t::apply () 1529bgPixmap_t::apply ()
1558{ 1530{
1559 if (target) 1531 if (target)
1560 { 1532 {
1561 flags &= ~isVtOrigin;
1562
1563 if (pixmap != None) 1533 if (pixmap != None)
1564 { 1534 {
1565 /* set target's background to pixmap */ 1535 /* set target's background to pixmap */
1566# ifdef ENABLE_TRANSPARENCY 1536# ifdef ENABLE_TRANSPARENCY
1567 if (flags & isTransparent) 1537 if (flags & isTransparent)
… …
1573 XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative); 1543 XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1574 } 1544 }
1575 else 1545 else
1576# endif 1546# endif
1577 { 1547 {
1578 flags |= isVtOrigin;
1579 /* force old pixmap dereference in case it was transparent before :*/ 1548 /* force old pixmap dereference in case it was transparent before :*/
1580 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]); 1549 XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1581 XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap); 1550 XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1582 /* do we also need to set scrollbar's background here ? */ 1551 /* do we also need to set scrollbar's background here ? */
1583 1552
… …
1610 } 1579 }
1611} 1580}
1612 1581
1613#endif /* HAVE_BG_PIXMAP */ 1582#endif /* HAVE_BG_PIXMAP */
1614 1583
1615#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XFT 1584#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XRENDER
1616/* taken from aterm-0.4.2 */ 1585/* taken from aterm-0.4.2 */
1617 1586
1618static void 1587static void
1619ShadeXImage(Visual *visual, XImage *srcImage, int shade, int rm, int gm, int bm) 1588ShadeXImage(Visual *visual, XImage *srcImage, int shade, int rm, int gm, int bm)
1620{ 1589{

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines