The R Project SVN R-packages

/*
 *  R : A Computer Langage for Statistical Data Analysis
 *  Copyright (C) 1998-2002   Lyndon Drake
 *                            and the R Development Core Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <math.h>
#include "gdkrotated.h"

static GdkPixmap* 
draw_layout_to_bitmap (PangoLayout *layout)
    /* 
       Render layout to a newly allocated bitmap
    */
{
    GdkPixmap *pixmap;
    PangoRectangle rect;
    GdkGC *gc;
    
    pango_layout_get_pixel_extents (layout, NULL, &rect);
    pixmap = gdk_pixmap_new (NULL, rect.width, rect.height, 1);
    gc = gdk_gc_new(pixmap);

    /* Clear the background */
    gdk_gc_set_function(gc, GDK_CLEAR);
    gdk_draw_rectangle(pixmap, gc, TRUE, 0, 0,
               rect.width, rect.height);

    /* Render the layout onto the bitmap */
    gdk_gc_set_function(gc, GDK_SET);
    gdk_draw_layout(pixmap, gc, 0, 0, layout);

    g_object_unref(gc);
    return pixmap;
}

static GdkPixbuf*
gdk_pixbuf_rotate(GdkPixbuf *source, double angle)
    /* 
       Returns a newly allocated pixbuf that contains the source
       pixbuf, rotated through "angle" radians.
    */
{
    GdkPixbuf *rpixbuf;
    int width, height, rowstride, rwidth, rheight, rrowstride;
    double costheta, sintheta;
    int i, j, k;
    guchar *pixels, *rpixels;
    int nchan, rnchan;

    g_return_val_if_fail(gdk_pixbuf_get_bits_per_sample(source)==8, NULL);
    g_return_val_if_fail(gdk_pixbuf_get_colorspace(source)==GDK_COLORSPACE_RGB,
             NULL);

    width = gdk_pixbuf_get_width(source);
    height = gdk_pixbuf_get_height(source);

    costheta = floor(cos(angle) * 1000.0 + 0.5) / 1000.0;
    sintheta = floor(sin(angle) * 1000.0 + 0.5) / 1000.0;
    
    /* Size of new pixbuf */
    rwidth = (int) (height * fabs(sintheta) + width * fabs(costheta));
    rheight = (int) (width * fabs(sintheta) + height * fabs(costheta));

    /* Create a new pixbuf of the required size and fill it
       with transparent black */
    rpixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, rwidth, rheight);
    gdk_pixbuf_fill(rpixbuf, 0x00000000);

    /* 
       Pixel-wise copying
    */
    rowstride = gdk_pixbuf_get_rowstride(source);
    pixels = gdk_pixbuf_get_pixels(source);
    nchan = gdk_pixbuf_get_n_channels(source);
    
    rrowstride = gdk_pixbuf_get_rowstride(rpixbuf);
    rpixels = gdk_pixbuf_get_pixels(rpixbuf);
    rnchan = gdk_pixbuf_get_n_channels(rpixbuf);

    for (i = 0; i < rwidth; i++)
    {
    double x, y;
    
    x = (i + 0.5) - rwidth/2;
    for (j = 0; j < rheight; j++)
    {
        double u, v;
        int p, q;
        
        y = rheight/2 - (j + 0.5);

        u = x * costheta + y * sintheta;
        v = - x * sintheta + y * costheta;

        p = (int) (u + width/2);
        q = (int) (height/2 - v);

        if (p >= 0 && p < width && q >= 0 && q < height) {
        for (k = 0; k < nchan; k++) {
            rpixels[j * rrowstride + rnchan * i + k]
            = pixels[q * rowstride + nchan * p + k];
        }
        }
    }
    }

    return(rpixbuf);
}

static void repaint_pixbuf (GdkPixbuf *pixbuf, guchar red, guchar green,
                guchar blue, GdkGC *gc)
    /* Repaints the pixels in pixbuf matching red, green and blue with
       the foreground cover of the graphics context gc */
{
    int i, j;
    GdkGCValues values;
    GdkColormap *colormap;
    guchar *pixels;
    int width, height, rowstride, nchan, index;

    gdk_gc_get_values(gc, &values);
    /* 
       Under X11, gdk_gc_get_values only fills in the pixel field
       for the foreground colour. We need to finish the job.  This
       is a bug in gdk.
    */
    colormap = gdk_gc_get_colormap(gc);
    gdk_colormap_query_color(colormap, values.foreground.pixel,
                 &(values.foreground));

    pixels = gdk_pixbuf_get_pixels(pixbuf);
    width = gdk_pixbuf_get_width(pixbuf);
    height = gdk_pixbuf_get_height(pixbuf);
    rowstride = gdk_pixbuf_get_rowstride(pixbuf);
    nchan = gdk_pixbuf_get_n_channels(pixbuf);

    for (i = 0; i < width; i ++) {
    for (j = 0; j < height; j++) {
        index = j * rowstride + i * nchan;
        if (pixels[index] == red && 
        pixels[index + 1] == green && 
        pixels[index + 2] == blue) 
        {
        pixels[index] =     values.foreground.red >> 8;
        pixels[index + 1] = values.foreground.green >> 8;
        pixels[index + 2] = values.foreground.blue >> 8;
        }
    }
    }


}

void gdk_draw_layout_rot(GdkDrawable *drawable,
             GdkGC *gc,
             int x,
             int y,
             PangoLayout *layout,
             double angle)
/* 
   GDK does not handle rotated text, so we have to render the text
   onto a pixmap, rotate it, and then render the result back onto the
   drawable.

   Since the rotation involves pixel-wise manipulation of the pixmap,
   we copy it over to a pixbuf - which is a client side object
   in X terminology - for greater efficiency.
*/
{
    PangoRectangle lrect;   
    PangoLayoutLine *line;

    g_return_if_fail(GDK_IS_GC(gc));
    g_return_if_fail(GDK_IS_DRAWABLE(drawable));
    
    line = pango_layout_get_line(layout, 0);
    pango_layout_line_get_pixel_extents(line, NULL, &lrect);    
    
    if(angle == 0.0) {
    gdk_draw_layout(drawable, gc,
            x - PANGO_LBEARING(lrect),
            y - PANGO_ASCENT(lrect), layout);
    }
    else {
    PangoRectangle rect;
    GdkPixmap *pixmap;
    GdkPixbuf *pixbuf, *tpixbuf, *rpixbuf;

    /* Render layout to a bitmap and then copy it to a pixbuf */
    pango_layout_get_pixel_extents(layout, NULL, &rect);
    pixmap = draw_layout_to_bitmap(layout);
    pixbuf = gdk_pixbuf_get_from_drawable(NULL, pixmap, NULL,
                          0, 0, 0, 0, 
                          rect.width, rect.height);
    g_object_unref(pixmap);
    if (!pixbuf)
        return;

    /* 
       Make a copy of pixbuf with an alpha channel, making
       the black pixels transparent and repainting the white
       pixels with the foreground colour
    */
    tpixbuf = gdk_pixbuf_add_alpha(pixbuf, TRUE, 0, 0, 0);
    repaint_pixbuf(tpixbuf, 255, 255, 255, gc);
    g_object_unref(pixbuf);

    rpixbuf = gdk_pixbuf_rotate (tpixbuf, angle);
    if (rpixbuf) {
        double u, v;
        int xnew, ynew;

        /* 
           u, v are coordinates of the centre of the text,
           with respect to the pivot point 
        */
        u = (rect.width/2 - PANGO_LBEARING(lrect)) * cos (angle) - 
        (rect.height/2 - PANGO_ASCENT(lrect)) * sin (angle); 
        v = (rect.width/2 - PANGO_LBEARING(lrect)) * sin (angle) + 
        (rect.height/2 - PANGO_RBEARING(lrect)) * cos (angle);

        /* 
           xnew, ynew are coordinates of the top left hand corner
           of rpixbuf
        */
        xnew = x + u - 3 * gdk_pixbuf_get_width(rpixbuf)/2;
        ynew = y + v - 3 * gdk_pixbuf_get_height(rpixbuf)/2;

        gdk_pixbuf_render_to_drawable (rpixbuf, drawable, gc, 
                       0, 0, xnew, ynew, -1, -1, 
                       GDK_RGB_DITHER_NONE, 0, 0);
        g_object_unref(rpixbuf);
    }
    g_object_unref(tpixbuf);
    }
}