X11TextRenderer_md.c

/*
 * Copyright (c) 2001, 2005, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

#include "GlyphImageRef.h"

#ifdef HEADLESS
#include "SurfaceData.h"
#else
#include "X11SurfaceData.h"
#include "GraphicsPrimitiveMgr.h"
#endif /* !HEADLESS */
#include <jlong.h>

#define TEXT_BM_WIDTH   1024
#define TEXT_BM_HEIGHT  32

#ifndef HEADLESS

static jboolean checkPixmap(JNIEnv *env, AwtGraphicsConfigDataPtr cData)
{
    XImage *img;
    int image_size;
    Window root;

    if (cData->monoImage == NULL) {
        img = XCreateImage(awt_display, NULL, 1, XYBitmap, 0, 0,
                                   TEXT_BM_WIDTH, TEXT_BM_HEIGHT, 32, 0);
        if (img != NULL) {
            image_size = img->bytes_per_line * TEXT_BM_HEIGHT;
            // assert(BM_W and BM_H are not large enough to overflow);
            img->data = (char *) malloc(image_size);
            if (img->data == NULL) {
                XFree(img);
            } else {
                // Force same bit/byte ordering
                img->bitmap_bit_order = img->byte_order;
                cData->monoImage = img;
            }
        }
        if (cData->monoImage == NULL) {
            JNU_ThrowOutOfMemoryError(env, "Cannot allocate bitmap for text");
            return JNI_FALSE;
        }
    }
    if (cData->monoPixmap == 0 ||
        cData->monoPixmapGC == NULL ||
        cData->monoPixmapWidth != TEXT_BM_WIDTH ||
        cData->monoPixmapHeight != TEXT_BM_HEIGHT)
    {
        if (cData->monoPixmap != 0) {
            XFreePixmap(awt_display, cData->monoPixmap);
            cData->monoPixmap = 0;
        }
        if (cData->monoPixmapGC != NULL) {
            XFreeGC(awt_display, cData->monoPixmapGC);
            cData->monoPixmapGC = 0;
        }
        root = RootWindow(awt_display, cData->awt_visInfo.screen);
        cData->monoPixmap = XCreatePixmap(awt_display, root,
                                          TEXT_BM_WIDTH, TEXT_BM_HEIGHT, 1);
        if (cData->monoPixmap == 0) {
            JNU_ThrowOutOfMemoryError(env, "Cannot allocate pixmap for text");
            return JNI_FALSE;
        }
        cData->monoPixmapGC = XCreateGC(awt_display, cData->monoPixmap,
                                        0, NULL);
        if (cData->monoPixmapGC == NULL) {
            XFreePixmap(awt_display, cData->monoPixmap);
            cData->monoPixmap = 0;
            JNU_ThrowOutOfMemoryError(env, "Cannot allocate pixmap for text");
            return JNI_FALSE;
        }
        XSetForeground(awt_display, cData->monoPixmapGC, 1);
        XSetBackground(awt_display, cData->monoPixmapGC, 0);
        cData->monoPixmapWidth = TEXT_BM_WIDTH;
        cData->monoPixmapHeight = TEXT_BM_HEIGHT;
    }
    return JNI_TRUE;
}

static void FillBitmap(XImage *theImage,
                       ImageRef *glyphs, jint totalGlyphs,
                       jint clipLeft, jint clipTop,
                       jint clipRight, jint clipBottom)
{
    int glyphCounter;
    int scan = theImage->bytes_per_line;
    int y, left, top, right, bottom, width, height;
    jubyte *pPix;
    const jubyte *pixels;
    unsigned int rowBytes;

    pPix = (jubyte *) theImage->data;
    glyphCounter = ((clipRight - clipLeft) + 7) >> 3;
    for (y = clipTop; y < clipBottom; y++) {
        memset(pPix, 0, glyphCounter);
        pPix += scan;
    }

    for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) {
        pixels = (const jubyte *)glyphs[glyphCounter].pixels;
        if (!pixels) {
            continue;
        }
        rowBytes = glyphs[glyphCounter].width;
        left     = glyphs[glyphCounter].x;
        top      = glyphs[glyphCounter].y;
        width    = glyphs[glyphCounter].width;
        height   = glyphs[glyphCounter].height;

        /* if any clipping required, modify parameters now */
        right  = left + width;
        bottom = top + height;
        if (left < clipLeft) {
            pixels += clipLeft - left;
            left = clipLeft;
        }
        if (top < clipTop) {
            pixels += (clipTop - top) * rowBytes;
            top = clipTop;
        }
        if (right > clipRight) {
            right = clipRight;
        }
        if (bottom > clipBottom) {
            bottom = clipBottom;
        }
        if (right <= left || bottom <= top) {
            continue;
        }
        width = right - left;
        height = bottom - top;
        top -= clipTop;
        left -= clipLeft;
        pPix = ((jubyte *) theImage->data) + (left >> 3) + (intptr_t) top * scan;
        left &= 0x07;
        if (theImage->bitmap_bit_order == MSBFirst) {
            left = 0x80 >> left;
            do {
                int x = 0, bx = 0;
                int pix = pPix[0];
                int bit = left;
                do {
                    if (bit == 0) {
                        pPix[bx] = (jubyte) pix;
                        pix = pPix[++bx];
                        bit = 0x80;
                    }
                    if (pixels[x]) {
                        pix |= bit;
                    }
                    bit >>= 1;
                } while (++x < width);
                pPix[bx] = (jubyte) pix;
                pPix += scan;
                pixels += rowBytes;
            } while (--height > 0);
        } else {
            left = 1 << left;
            do {
                int x = 0, bx = 0;
                int pix = pPix[0];
                int bit = left;
                do {
                    if ((bit >> 8) != 0) {
                        pPix[bx] = (jubyte) pix;
                        pix = pPix[++bx];
                        bit = 1;
                    }
                    if (pixels[x]) {
                        pix |= bit;
                    }
                    bit <<= 1;
                } while (++x < width);
                pPix[bx] = (jubyte) pix;
                pPix += scan;
                pixels += rowBytes;
            } while (--height > 0);
        }
    }
}
#endif /* !HEADLESS */

JNIEXPORT void JNICALL
AWTDrawGlyphList(JNIEnv *env, jobject xtr,
                 jlong dstData, jlong gc,
                 SurfaceDataBounds *bounds, ImageRef *glyphs, jint totalGlyphs)
{
#ifndef HEADLESS
    GC xgc, theGC;
    XImage *theImage;
    Pixmap thePixmap;
    XGCValues xgcv;
    int scan, screen;
    AwtGraphicsConfigDataPtr cData;
    X11SDOps *xsdo = (X11SDOps *)jlong_to_ptr(dstData);
    jint cx1, cy1, cx2, cy2;

    if (xsdo == NULL) {
        return;
    }

    xgc = (GC)gc;
    if (xgc == NULL) {
        return;
    }

    screen = xsdo->configData->awt_visInfo.screen;
    cData = getDefaultConfig(screen);
    if (!checkPixmap(env, cData)) {
        return;
    }
    theImage = cData->monoImage;
    thePixmap = cData->monoPixmap;
    theGC = cData->monoPixmapGC;

    scan = theImage->bytes_per_line;

    xgcv.fill_style = FillStippled;
    xgcv.stipple = thePixmap;
    xgcv.ts_x_origin = bounds->x1;
    xgcv.ts_y_origin = bounds->y1;
    XChangeGC(awt_display, xgc,
              GCFillStyle | GCStipple | GCTileStipXOrigin | GCTileStipYOrigin,
              &xgcv);

    cy1 = bounds->y1;
    while (cy1 < bounds->y2) {
        cy2 = cy1 + TEXT_BM_HEIGHT;
        if (cy2 > bounds->y2) cy2 = bounds->y2;

        cx1 = bounds->x1;
        while (cx1 < bounds->x2) {
            cx2 = cx1 + TEXT_BM_WIDTH;
            if (cx2 > bounds->x2) cx2 = bounds->x2;

            FillBitmap(theImage,
                       glyphs,
                       totalGlyphs,
                       cx1, cy1, cx2, cy2);

            // NOTE: Since we are tiling around by BM_W, BM_H offsets
            // and thePixmap is BM_W x BM_H, we do not have to move
            // the TSOrigin at each step since the stipple repeats
            // every BM_W, BM_H units
            XPutImage(awt_display, thePixmap, theGC, theImage,
                      0, 0, 0, 0, cx2 - cx1, cy2 - cy1);
            /* MGA on Linux doesn't pick up the new stipple image data,
             * probably because it caches the image as a hardware pixmap
             * and doesn't update it when the pixmap image data is changed.
             * So if the loop is executed more than once, update the GC
             * which triggers the required behaviour. This extra XChangeGC
             * call only happens on large or rotated text so isn't a
             * significant new overhead..
             * This code needs to execute on a Solaris client too, in case
             * we are remote displaying to a MGA.
             */
            if (cy1 != bounds->y1 || cx1 != bounds->x1) {
                XChangeGC(awt_display, xgc, GCStipple, &xgcv);
            }

            XFillRectangle(awt_display, xsdo->drawable, xgc,
                           cx1, cy1, cx2 - cx1, cy2 - cy1);

            cx1 = cx2;
        }

        cy1 = cy2;
    }
    XSetFillStyle(awt_display, xgc, FillSolid);

    X11SD_DirectRenderNotify(env, xsdo);
#endif /* !HEADLESS */
}