xorg-server-1.4/hw/xgl/xglfill.c

   1 /*
   2  * Copyright © 2004 David Reveman
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software
   5  * and its documentation for any purpose is hereby granted without
   6  * fee, provided that the above copyright notice appear in all copies
   7  * and that both that copyright notice and this permission notice
   8  * appear in supporting documentation, and that the name of
   9  * David Reveman not be used in advertising or publicity pertaining to
  10  * distribution of the software without specific, written prior permission.
  11  * David Reveman makes no representations about the suitability of this
  12  * software for any purpose. It is provided "as is" without express or
  13  * implied warranty.
  14  *
  15  * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  16  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
  17  * NO EVENT SHALL DAVID REVEMAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  18  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
  19  * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  20  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  21  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22  *
  23  * Author: David Reveman <davidr@novell.com>
  24  */
  25
  26 #include "xgl.h"
  27 #include "gcstruct.h"
  28 #include "fb.h"
  29
  30 Bool
  31 xglFill (DrawablePtr    pDrawable,
  32          GCPtr          pGC,
  33          xglGeometryPtr pGeometry,
  34          int            x,
  35          int            y,
  36          int            width,
  37          int            height,
  38          BoxPtr         pBox,
  39          int            nBox)
  40 {
  41     XGL_GC_PRIV (pGC);
  42
  43     switch (pGC->fillStyle) {
  44     case FillSolid:
  45         if (xglSolid (pDrawable,
  46                       pGCPriv->op, pGCPriv->fg,
  47                       pGeometry,
  48                       x, y,
  49                       width, height,
  50                       pBox, nBox))
  51             return TRUE;
  52         break;
  53     case FillStippled:
  54     case FillOpaqueStippled:
  55         break;
  56     case FillTiled:
  57         if (xglTile (pDrawable,
  58                      pGCPriv->op, pGC->tile.pixmap,
  59                      -(pGC->patOrg.x + pDrawable->x),
  60                      -(pGC->patOrg.y + pDrawable->y),
  61                      pGeometry,
  62                      x, y,
  63                      width, height,
  64                      pBox, nBox))
  65             return TRUE;
  66         break;
  67     }
  68
  69     return FALSE;
  70 }
  71
  72 static void
  73 xglFillBox (DrawablePtr pDrawable,
  74             GCPtr       pGC,
  75             int         x,
  76             int         y,
  77             int         width,
  78             int         height,
  79             BoxPtr      pBox,
  80             int         nBox)
  81 {
  82     if (!nBox)
  83         return;
  84
  85     if (!xglFill (pDrawable, pGC, NULL, x, y, width, height, pBox, nBox))
  86     {
  87         RegionRec region;
  88
  89         XGL_DRAWABLE_PIXMAP (pDrawable);
  90         XGL_PIXMAP_PRIV (pPixmap);
  91
  92         if (!xglMapPixmapBits (pPixmap))
  93             FatalError (XGL_SW_FAILURE_STRING);
  94
  95         switch (pGC->fillStyle) {
  96         case FillSolid:
  97             break;
  98         case FillStippled:
  99         case FillOpaqueStippled:
 100             if (!xglSyncBits (&pGC->stipple->drawable, NullBox))
 101                 FatalError (XGL_SW_FAILURE_STRING);
 102             break;
 103         case FillTiled:
 104             if (!xglSyncBits (&pGC->tile.pixmap->drawable, NullBox))
 105                 FatalError (XGL_SW_FAILURE_STRING);
 106             break;
 107         }
 108
 109         pPixmapPriv->damageBox = miEmptyBox;
 110
 111         while (nBox--)
 112         {
 113             fbFill (pDrawable, pGC,
 114                     pBox->x1, pBox->y1,
 115                     pBox->x2 - pBox->x1, pBox->y2 - pBox->y1);
 116
 117             REGION_INIT (pDrawable->pScreen, &region, pBox, 1);
 118             xglAddSurfaceDamage (pDrawable, &region);
 119             REGION_UNINIT (pDrawable->pScreen, &region);
 120
 121             pBox++;
 122         }
 123     } else
 124         xglAddCurrentBitDamage (pDrawable);
 125 }
 126
 127 #define N_STACK_BOX 1024
 128
 129 static BoxPtr
 130 xglMoreBoxes (BoxPtr stackBox,
 131               BoxPtr heapBox,
 132               int    nBoxes)
 133 {
 134     Bool stack = !heapBox;
 135
 136     heapBox = xrealloc (heapBox, sizeof (BoxRec) * nBoxes);
 137     if (!heapBox)
 138         return NULL;
 139
 140     if (stack)
 141         memcpy (heapBox, stackBox, sizeof (BoxRec) * N_STACK_BOX);
 142
 143     return heapBox;
 144 }
 145
 146 #define ADD_BOX(pBox, nBox, stackBox, heapBox, size, box)       \
 147     {                                                           \
 148         if ((nBox) == (size))                                   \
 149         {                                                       \
 150             (size) *= 2;                                        \
 151             (heapBox) = xglMoreBoxes (stackBox, heapBox, size); \
 152             if (heapBox)                                        \
 153             {                                                   \
 154                 (pBox) = (heapBox) + (nBox);                    \
 155                 *(pBox)++ = (box);                              \
 156                 (nBox)++;                                       \
 157             }                                                   \
 158         }                                                       \
 159         else                                                    \
 160         {                                                       \
 161             *(pBox)++ = (box);                                  \
 162             (nBox)++;                                           \
 163         }                                                       \
 164     }
 165
 166 void
 167 xglFillRect (DrawablePtr pDrawable,
 168              GCPtr       pGC,
 169              int         nrect,
 170              xRectangle  *prect)
 171 {
 172     RegionPtr pClip = pGC->pCompositeClip;
 173     BoxPtr    pClipBox;
 174     BoxPtr    pExtent = REGION_EXTENTS (pGC->pScreen, pClip);
 175     BoxRec    part, full;
 176     BoxPtr    heapBox = NULL;
 177     BoxRec    stackBox[N_STACK_BOX];
 178     int       size = N_STACK_BOX;
 179     BoxPtr    pBox = stackBox;
 180     int       nClip, nBox = 0;
 181
 182     while (nrect--)
 183     {
 184         full.x1 = prect->x + pDrawable->x;
 185         full.y1 = prect->y + pDrawable->y;
 186         full.x2 = full.x1 + (int) prect->width;
 187         full.y2 = full.y1 + (int) prect->height;
 188
 189         prect++;
 190
 191         if (full.x1 < pExtent->x1)
 192             full.x1 = pExtent->x1;
 193         if (full.y1 < pExtent->y1)
 194             full.y1 = pExtent->y1;
 195         if (full.x2 > pExtent->x2)
 196             full.x2 = pExtent->x2;
 197         if (full.y2 > pExtent->y2)
 198             full.y2 = pExtent->y2;
 199
 200         if (full.x1 >= full.x2 || full.y1 >= full.y2)
 201             continue;
 202
 203         nClip = REGION_NUM_RECTS (pClip);
 204         if (nClip == 1)
 205         {
 206             ADD_BOX (pBox, nBox, stackBox, heapBox, size, full);
 207         }
 208         else
 209         {
 210             pClipBox = REGION_RECTS (pClip);
 211             while (nClip--)
 212             {
 213                 part = *pClipBox++;
 214
 215                 if (part.x1 < full.x1)
 216                     part.x1 = full.x1;
 217                 if (part.y1 < full.y1)
 218                     part.y1 = full.y1;
 219                 if (part.x2 > full.x2)
 220                     part.x2 = full.x2;
 221                 if (part.y2 > full.y2)
 222                     part.y2 = full.y2;
 223
 224                 if (part.x1 < part.x2 && part.y1 < part.y2)
 225                     ADD_BOX (pBox, nBox, stackBox, heapBox, size, part);
 226             }
 227         }
 228     }
 229
 230     xglFillBox (pDrawable, pGC,
 231                 pExtent->x1, pExtent->y1,
 232                 pExtent->x2 - pExtent->x1, pExtent->y2 - pExtent->y1,
 233                 (heapBox) ? heapBox : stackBox, nBox);
 234
 235     if (heapBox)
 236         xfree (heapBox);
 237 }
 238
 239 void
 240 xglFillSpan (DrawablePtr pDrawable,
 241              GCPtr       pGC,
 242              int         n,
 243              DDXPointPtr ppt,
 244              int         *pwidth)
 245 {
 246     RegionPtr pClip = pGC->pCompositeClip;
 247     BoxPtr    pClipBox;
 248     BoxPtr    pExtent = REGION_EXTENTS (pGC->pScreen, pClip);
 249     BoxRec    part, full;
 250     BoxPtr    heapBox = NULL;
 251     BoxRec    stackBox[N_STACK_BOX];
 252     int       size = N_STACK_BOX;
 253     BoxPtr    pBox = stackBox;
 254     int       nClip, nBox = 0;
 255
 256     while (n--)
 257     {
 258         full.x1 = ppt->x;
 259         full.y1 = ppt->y;
 260         full.x2 = full.x1 + *pwidth;
 261         full.y2 = full.y1 + 1;
 262
 263         pwidth++;
 264         ppt++;
 265
 266         if (full.x1 < pExtent->x1)
 267             full.x1 = pExtent->x1;
 268         if (full.y1 < pExtent->y1)
 269             full.y1 = pExtent->y1;
 270         if (full.x2 > pExtent->x2)
 271             full.x2 = pExtent->x2;
 272         if (full.y2 > pExtent->y2)
 273             full.y2 = pExtent->y2;
 274
 275         if (full.x1 >= full.x2 || full.y1 >= full.y2)
 276             continue;
 277
 278         nClip = REGION_NUM_RECTS (pClip);
 279         if (nClip == 1)
 280         {
 281             ADD_BOX (pBox, nBox, stackBox, heapBox, size, full);
 282         }
 283         else
 284         {
 285             pClipBox = REGION_RECTS (pClip);
 286             while (nClip--)
 287             {
 288                 part = *pClipBox++;
 289
 290                 if (part.x1 < full.x1)
 291                     part.x1 = full.x1;
 292                 if (part.y1 < full.y1)
 293                     part.y1 = full.y1;
 294                 if (part.x2 > full.x2)
 295                     part.x2 = full.x2;
 296                 if (part.y2 > full.y2)
 297                     part.y2 = full.y2;
 298
 299                 if (part.x1 < part.x2 && part.y1 < part.y2)
 300                     ADD_BOX (pBox, nBox, stackBox, heapBox, size, part);
 301             }
 302         }
 303     }
 304
 305     xglFillBox (pDrawable, pGC,
 306                 pExtent->x1, pExtent->y1,
 307                 pExtent->x2 - pExtent->x1, pExtent->y2 - pExtent->y1,
 308                 (heapBox) ? heapBox : stackBox, nBox);
 309
 310     if (heapBox)
 311         xfree (heapBox);
 312 }
 313
 314 Bool
 315 xglFillLine (DrawablePtr pDrawable,
 316              GCPtr       pGC,
 317              int         mode,
 318              int         npt,
 319              DDXPointPtr ppt)
 320 {
 321     RegionPtr      pClip = pGC->pCompositeClip;
 322     BoxPtr         pExtent = REGION_EXTENTS (pGC->pScreen, pClip);
 323     Bool           coincidentEndpoints = FALSE;
 324     Bool           horizontalAndVertical = TRUE;
 325     DDXPointPtr    pptTmp;
 326     int            nptTmp;
 327     DDXPointRec    pt;
 328     xglGeometryPtr pGeometry;
 329
 330     XGL_SCREEN_PRIV (pGC->pScreen);
 331
 332     if (npt < 2)
 333         return TRUE;
 334
 335     pt = *ppt;
 336
 337     nptTmp = npt - 1;
 338     pptTmp = ppt + 1;
 339
 340     if (mode == CoordModePrevious)
 341     {
 342         while (nptTmp--)
 343         {
 344             if (pptTmp->x && pptTmp->y)
 345                 horizontalAndVertical = FALSE;
 346
 347             pt.x += pptTmp->x;
 348             pt.y += pptTmp->y;
 349
 350             pptTmp++;
 351         }
 352
 353         if (pt.x == ppt->x && pt.y == ppt->y)
 354             coincidentEndpoints = TRUE;
 355     }
 356     else
 357     {
 358         while (nptTmp--)
 359         {
 360             if (pptTmp->x != pt.x && pptTmp->y != pt.y)
 361             {
 362                 horizontalAndVertical = FALSE;
 363                 break;
 364             }
 365
 366             pt = *pptTmp++;
 367         }
 368
 369         if (ppt[npt - 1].x == ppt->x && ppt[npt - 1].y == ppt->y)
 370             coincidentEndpoints = TRUE;
 371     }
 372
 373     if (horizontalAndVertical)
 374     {
 375         BoxPtr pClipBox;
 376         BoxRec part, full;
 377         BoxPtr heapBox = NULL;
 378         BoxRec stackBox[N_STACK_BOX];
 379         int    size = N_STACK_BOX;
 380         BoxPtr pBox = stackBox;
 381         int    nClip, nBox = 0;
 382         int    dx, dy;
 383
 384         pt = *ppt;
 385
 386         ppt++;
 387         npt--;
 388
 389         while (npt--)
 390         {
 391             if (mode == CoordModePrevious)
 392             {
 393                 dx = ppt->x;
 394                 dy = ppt->y;
 395             }
 396             else
 397             {
 398                 dx = ppt->x - pt.x;
 399                 dy = ppt->y - pt.y;
 400             }
 401
 402             if (dx)
 403             {
 404                 if (dx > 0)
 405                 {
 406                     full.x1 = pt.x + pDrawable->x;
 407
 408                     if (npt || coincidentEndpoints)
 409                         full.x2 = full.x1 + dx;
 410                     else
 411                         full.x2 = full.x1 + dx + 1;
 412                 }
 413                 else
 414                 {
 415                     full.x2 = pt.x + pDrawable->x + 1;
 416
 417                     if (npt || coincidentEndpoints)
 418                         full.x1 = full.x2 + dx;
 419                     else
 420                         full.x1 = full.x2 + dx - 1;
 421                 }
 422
 423                 full.y1 = pt.y + pDrawable->y;
 424                 full.y2 = full.y1 + 1;
 425             }
 426             else
 427             {
 428                 if (dy > 0)
 429                 {
 430                     full.y1 = pt.y + pDrawable->y;
 431
 432                     if (npt || coincidentEndpoints)
 433                         full.y2 = full.y1 + dy;
 434                     else
 435                         full.y2 = full.y1 + dy + 1;
 436                 }
 437                 else
 438                 {
 439                     full.y2 = pt.y + pDrawable->y + 1;
 440
 441                     if (npt || coincidentEndpoints)
 442                         full.y1 = full.y2 + dy;
 443                     else
 444                         full.y1 = full.y2 + dy - 1;
 445                 }
 446
 447                 full.x1 = pt.x + pDrawable->x;
 448                 full.x2 = full.x1 + 1;
 449             }
 450
 451             pt.x += dx;
 452             pt.y += dy;
 453
 454             ppt++;
 455
 456             if (full.x1 < pExtent->x1)
 457                 full.x1 = pExtent->x1;
 458             if (full.y1 < pExtent->y1)
 459                 full.y1 = pExtent->y1;
 460             if (full.x2 > pExtent->x2)
 461                 full.x2 = pExtent->x2;
 462             if (full.y2 > pExtent->y2)
 463                 full.y2 = pExtent->y2;
 464
 465             if (full.x1 >= full.x2 || full.y1 >= full.y2)
 466                 continue;
 467
 468             nClip = REGION_NUM_RECTS (pClip);
 469             if (nClip == 1)
 470             {
 471                 ADD_BOX (pBox, nBox, stackBox, heapBox, size, full);
 472             }
 473             else
 474             {
 475                 pClipBox = REGION_RECTS (pClip);
 476                 while (nClip--)
 477                 {
 478                     part = *pClipBox++;
 479
 480                     if (part.x1 < full.x1)
 481                         part.x1 = full.x1;
 482                     if (part.y1 < full.y1)
 483                         part.y1 = full.y1;
 484                     if (part.x2 > full.x2)
 485                         part.x2 = full.x2;
 486                     if (part.y2 > full.y2)
 487                         part.y2 = full.y2;
 488
 489                     if (part.x1 < part.x2 && part.y1 < part.y2)
 490                         ADD_BOX (pBox, nBox, stackBox, heapBox, size, part);
 491                 }
 492             }
 493         }
 494
 495         xglFillBox (pDrawable, pGC,
 496                     pExtent->x1, pExtent->y1,
 497                     pExtent->x2 - pExtent->x1, pExtent->y2 - pExtent->y1,
 498                     (heapBox) ? heapBox : stackBox, nBox);
 499
 500         if (heapBox)
 501             xfree (heapBox);
 502
 503         return TRUE;
 504     }
 505
 506     if (!pScreenPriv->lines)
 507         return FALSE;
 508
 509     if (coincidentEndpoints)
 510         npt--;
 511
 512     pGeometry = xglGetScratchVertexGeometry (pGC->pScreen, npt);
 513
 514     GEOMETRY_ADD_LINE (pGC->pScreen, pGeometry,
 515                        coincidentEndpoints, mode, npt, ppt);
 516
 517     if (coincidentEndpoints)
 518         GEOMETRY_SET_VERTEX_PRIMITIVE (pGeometry, GLITZ_PRIMITIVE_LINE_LOOP);
 519     else
 520         GEOMETRY_SET_VERTEX_PRIMITIVE (pGeometry, GLITZ_PRIMITIVE_LINE_STRIP);
 521
 522     /* Lines need a 0.5 translate */
 523     GEOMETRY_TRANSLATE_FIXED (pGeometry, 1 << 15, 1 << 15);
 524
 525     GEOMETRY_TRANSLATE (pGeometry, pDrawable->x, pDrawable->y);
 526
 527     pExtent = REGION_EXTENTS (pDrawable->pScreen, pGC->pCompositeClip);
 528
 529     if (xglFill (pDrawable, pGC, pGeometry,
 530                  pExtent->x1, pExtent->y1,
 531                  pExtent->x2 - pExtent->x1, pExtent->y2 - pExtent->y1,
 532                  REGION_RECTS (pGC->pCompositeClip),
 533                  REGION_NUM_RECTS (pGC->pCompositeClip)))
 534     {
 535         xglAddCurrentBitDamage (pDrawable);
 536         return TRUE;
 537     }
 538
 539     return FALSE;
 540 }
 541
 542 Bool
 543 xglFillSegment (DrawablePtr pDrawable,
 544                 GCPtr       pGC,
 545                 int         nSegInit,
 546                 xSegment    *pSegInit)
 547 {
 548     RegionPtr      pClip = pGC->pCompositeClip;
 549     BoxPtr         pExtent = REGION_EXTENTS (pGC->pScreen, pClip);
 550     Bool           horizontalAndVertical = TRUE;
 551     xglGeometryPtr pGeometry;
 552     xSegment       *pSeg;
 553     int            nSeg;
 554
 555     XGL_SCREEN_PRIV (pGC->pScreen);
 556
 557     if (nSegInit < 1)
 558         return TRUE;
 559
 560     pSeg = pSegInit;
 561     nSeg = nSegInit;
 562     while (nSeg--)
 563     {
 564         if (pSeg->x1 != pSeg->x2 && pSeg->y1 != pSeg->y2)
 565             horizontalAndVertical = FALSE;
 566
 567         pSeg++;
 568     }
 569
 570     if (horizontalAndVertical)
 571     {
 572         BoxPtr pClipBox;
 573         BoxRec part, full;
 574         BoxPtr heapBox = NULL;
 575         BoxRec stackBox[N_STACK_BOX];
 576         int    size = N_STACK_BOX;
 577         BoxPtr pBox = stackBox;
 578         int    nClip, nBox = 0;
 579
 580         while (nSegInit--)
 581         {
 582             if (pSegInit->x1 != pSegInit->x2)
 583             {
 584                 if (pSegInit->x1 < pSegInit->x2)
 585                 {
 586                     full.x1 = pSegInit->x1;
 587                     full.x2 = pSegInit->x2;
 588                 }
 589                 else
 590                 {
 591                     full.x1 = pSegInit->x2;
 592                     full.x2 = pSegInit->x1;
 593                 }
 594
 595                 full.x1 += pDrawable->x;
 596                 full.x2 += pDrawable->x + 1;
 597                 full.y1  = pSegInit->y1 + pDrawable->y;
 598                 full.y2  = full.y1 + 1;
 599             }
 600             else
 601             {
 602                 if (pSegInit->y1 < pSegInit->y2)
 603                 {
 604                     full.y1 = pSegInit->y1;
 605                     full.y2 = pSegInit->y2;
 606                 }
 607                 else
 608                 {
 609                     full.y1 = pSegInit->y2;
 610                     full.y2 = pSegInit->y1;
 611                 }
 612
 613                 full.y1 += pDrawable->y;
 614                 full.y2 += pDrawable->y + 1;
 615                 full.x1  = pSegInit->x1 + pDrawable->x;
 616                 full.x2  = full.x1 + 1;
 617             }
 618
 619             pSegInit++;
 620
 621             if (full.x1 < pExtent->x1)
 622                 full.x1 = pExtent->x1;
 623             if (full.y1 < pExtent->y1)
 624                 full.y1 = pExtent->y1;
 625             if (full.x2 > pExtent->x2)
 626                 full.x2 = pExtent->x2;
 627             if (full.y2 > pExtent->y2)
 628                 full.y2 = pExtent->y2;
 629
 630             if (full.x1 >= full.x2 || full.y1 >= full.y2)
 631                 continue;
 632
 633             nClip = REGION_NUM_RECTS (pClip);
 634             if (nClip == 1)
 635             {
 636                 ADD_BOX (pBox, nBox, stackBox, heapBox, size, full);
 637             }
 638             else
 639             {
 640                 pClipBox = REGION_RECTS (pClip);
 641                 while (nClip--)
 642                 {
 643                     part = *pClipBox++;
 644
 645                     if (part.x1 < full.x1)
 646                         part.x1 = full.x1;
 647                     if (part.y1 < full.y1)
 648                         part.y1 = full.y1;
 649                     if (part.x2 > full.x2)
 650                         part.x2 = full.x2;
 651                     if (part.y2 > full.y2)
 652                         part.y2 = full.y2;
 653
 654                     if (part.x1 < part.x2 && part.y1 < part.y2)
 655                         ADD_BOX (pBox, nBox, stackBox, heapBox, size, part);
 656                 }
 657             }
 658         }
 659
 660         xglFillBox (pDrawable, pGC,
 661                     pExtent->x1, pExtent->y1,
 662                     pExtent->x2 - pExtent->x1, pExtent->y2 - pExtent->y1,
 663                     (heapBox) ? heapBox : stackBox, nBox);
 664
 665         if (heapBox)
 666             xfree (heapBox);
 667
 668         return TRUE;
 669     }
 670
 671     if (!pScreenPriv->lines)
 672         return FALSE;
 673
 674     pGeometry = xglGetScratchVertexGeometry (pGC->pScreen, 2 * nSegInit);
 675
 676     GEOMETRY_ADD_SEGMENT (pGC->pScreen, pGeometry, nSegInit, pSegInit);
 677
 678     /* Line segments need 0.5 translate */
 679     GEOMETRY_TRANSLATE_FIXED (pGeometry, 1 << 15, 1 << 15);
 680     GEOMETRY_SET_VERTEX_PRIMITIVE (pGeometry, GLITZ_PRIMITIVE_LINES);
 681
 682     GEOMETRY_TRANSLATE (pGeometry, pDrawable->x, pDrawable->y);
 683
 684     if (xglFill (pDrawable, pGC, pGeometry,
 685                  pExtent->x1, pExtent->y1,
 686                  pExtent->x2 - pExtent->x1, pExtent->y2 - pExtent->y1,
 687                  REGION_RECTS (pGC->pCompositeClip),
 688                  REGION_NUM_RECTS (pGC->pCompositeClip)))
 689     {
 690         xglAddCurrentBitDamage (pDrawable);
 691         return TRUE;
 692     }
 693
 694     return FALSE;
 695 }
 696
 697 Bool
 698 xglFillGlyph (DrawablePtr  pDrawable,
 699               GCPtr        pGC,
 700               int          x,
 701               int          y,
 702               unsigned int nGlyph,
 703               CharInfoPtr  *ppci,
 704               pointer      pglyphBase)
 705 {
 706     BoxPtr         pExtent;
 707     xglGeometryRec geometry;
 708
 709     if (nGlyph < 1)
 710         return TRUE;
 711
 712     pExtent = REGION_EXTENTS (pDrawable->pScreen, pGC->pCompositeClip);
 713
 714     x += pDrawable->x;
 715     y += pDrawable->y;
 716
 717     GEOMETRY_INIT (pDrawable->pScreen, &geometry,
 718                    GLITZ_GEOMETRY_TYPE_BITMAP,
 719                    GEOMETRY_USAGE_SYSMEM, 0);
 720
 721     GEOMETRY_FOR_GLYPH (pDrawable->pScreen,
 722                         &geometry,
 723                         nGlyph,
 724                         ppci,
 725                         pglyphBase);
 726
 727     GEOMETRY_TRANSLATE (&geometry, x, y);
 728
 729     if (xglFill (pDrawable, pGC, &geometry,
 730                  pExtent->x1, pExtent->y1,
 731                  pExtent->x2 - pExtent->x1, pExtent->y2 - pExtent->y1,
 732                  REGION_RECTS (pGC->pCompositeClip),
 733                  REGION_NUM_RECTS (pGC->pCompositeClip)))
 734     {
 735         GEOMETRY_UNINIT (&geometry);
 736         xglAddCurrentBitDamage (pDrawable);
 737         return TRUE;
 738     }
 739
 740     GEOMETRY_UNINIT (&geometry);
 741     return FALSE;
 742 }