static void
x_img_tmp_draw_tile_opaque(int tile, int ofsx, int ofsy)
{
int i, j;
guint32 pixel;
int width, height;
int srcx, srcy;
width = tmp_img->width;
height = tmp_img->height;
srcx = (tile % tiles_per_row) * Tile->unit_width;
srcy = (tile / tiles_per_row) * Tile->unit_height;
if (ofsx < 0) {
srcx -= ofsx;
width += ofsx;
ofsx = 0;
}
if (ofsy < 0) {
srcy -= ofsy;
height += ofsy;
ofsy = 0;
}
if (ofsx > 0)
width -= ofsx;
if (ofsy > 0)
height -= ofsy;
for(j = 0; j < height; j++)
for(i = 0; i < width; i++) {
pixel = gdk_image_get_pixel(tile_image, srcx + i, srcy + j);
gdk_image_put_pixel(tmp_img, ofsx + i, ofsy + j, pixel);
}
}
static void
x_img_tmp_draw_tile_transp(int tile, int ofsx, int ofsy)
{
int i, j, n;
guint32 pixel;
int width, height;
int srcx, srcy;
struct tile_transp *t = &tile_transp[tile];
unsigned char *rle = t->data;
width = tmp_img->width;
height = tmp_img->height;
srcx = (tile % tiles_per_row) * Tile->unit_width;
srcy = (tile / tiles_per_row) * Tile->unit_height;
for(j = t->oy; j < t->oy + t->ny; j++) {
for(i = t->ox + *rle++; i < t->ox + t->nx; ) {
for(n = *rle++; n; i++, n--) {
if (ofsx + i >= 0 && ofsx + i < width &&
ofsy + j >= 0 && ofsy + j < height) {
pixel = gdk_image_get_pixel(tile_image, srcx + i, srcy + j);
gdk_image_put_pixel(tmp_img, ofsx + i, ofsy + j, pixel);
}
}
if (i < t->ox + t->nx)
i += *rle++;
}
#ifdef DEBUG
if (i != t->ox + t->nx) impossible("Transparency data misalign");
#endif
}
}
static GdkPixmap *
scale_pixmap (GdkWindow *window, GdkPixmap *pixmap, gdouble scale_x, gdouble scale_y)
{
GdkGC *gc;
GdkColormap *colormap;
GdkColorContext *cc;
GdkVisual *visual;
GdkImage *image;
GdkPixmap *new_pixmap;
gint x, y, width, height, new_width, new_height;
if(!pixmap) return NULL;
if(!window) return NULL;
gc = gdk_gc_new(pixmap);
colormap = gdk_colormap_get_system ();
visual = gdk_visual_get_system ();
cc = gdk_color_context_new(visual, colormap);
gdk_window_get_size(pixmap, &width, &height);
if(scale_x == 1.0 && scale_y == 1.0){
new_pixmap = gdk_pixmap_new(window, width, height, -1);
gdk_draw_pixmap(new_pixmap,
gc,
pixmap,
0, 0,
0, 0,
width, height);
return new_pixmap;
}
new_width = roundint(width * scale_x);
new_height = roundint(height * scale_y);
new_pixmap = gdk_pixmap_new(window, new_width, new_height, -1);
image = gdk_image_get(pixmap,
0, 0,
width, height);
for(x = 0; x < new_width; x++){
for(y = 0; y < new_height; y++){
GdkColor color;
gint px, py;
px = MIN(roundint(x / scale_x), width - 1);
py = MIN(roundint(y / scale_y), height - 1);
color.pixel = gdk_image_get_pixel(image, px, py);
gdk_color_context_query_color(cc, &color);
gdk_gc_set_foreground(gc, &color);
gdk_draw_point(new_pixmap, gc, x, y);
}
}
gdk_image_destroy(image);
gdk_color_context_free(cc);
return new_pixmap;
}
static void
psdrawpixmap (GtkPlotPC *pc,
GdkPixmap *pixmap,
GdkBitmap *mask,
gint xsrc, gint ysrc,
gint xdest, gint ydest,
gint width, gint height,
gdouble scale_x, gdouble scale_y)
{
FILE *psout = GTK_PLOT_PS(pc)->psfile;
GdkColormap *colormap;
colormap = gdk_colormap_get_system ();
fprintf(psout, "gsave\n");
if(pixmap){
GdkImage *image;
gint x, y;
image = gdk_image_get(pixmap,
xsrc, ysrc,
width, height);
if(mask) gtk_plot_pc_clip_mask(pc, xdest, ydest, mask);
fprintf(psout, "%d %g translate\n", xdest, ydest + height * scale_y);
fprintf(psout, "%g %g scale\n",width * scale_x, height * scale_y);
fprintf(psout, "%d %d 8 [%d 0 0 %d 0 %d]\n",width, height, width, height, height);
fprintf(psout, "/scanline %d 3 mul string def\n", width);
fprintf(psout, "{ currentfile scanline readhexstring pop } false 3\n");
fprintf(psout, "colorimage\n");
for(y = 0; y < height; y++){
for(x = 0; x < width; x++){
GdkColor color;
gchar string[7];
color.pixel = gdk_image_get_pixel(image, x, y);
gdk_colormap_query_color(colormap, color.pixel, &color);
color_to_hex(color, string);
fprintf(psout,"%s",string);
if(fmod(x + 1, 13) == 0) fprintf(psout, "\n");
}
fprintf(psout,"\n");
}
gdk_image_destroy(image);
if(mask) gtk_plot_pc_clip_mask(pc, xdest, ydest, NULL);
}
fprintf(psout, "grestore\n");
}
static void
load_scenario (char *fname)
{
char *tmp, *fn;
GdkColor bgcolor;
GdkImage *tmpimage;
tmp = g_strconcat ( "same-gnome/", fname, NULL);
fn = gnome_unconditional_pixmap_file ( tmp );
g_free( tmp );
if (!g_file_exists (fn)) {
printf (_("Could not find the \'%s\' theme for SameGnome\n"), fn);
exit (1);
}
if (scenario)
g_free (scenario);
scenario = g_strdup(fname);
configure_sync (fname);
if (image)
gdk_imlib_destroy_image (image);
image = gdk_imlib_load_image (fn);
gdk_imlib_render (image, image->rgb_width, image->rgb_height);
stones = gdk_imlib_move_image (image);
mask = gdk_imlib_move_mask (image);
tmpimage = gdk_image_get(stones, 0, 0, 1, 1);
bgcolor.pixel = gdk_image_get_pixel(tmpimage, 0, 0);
gdk_window_set_background (draw_area->window, &bgcolor);
gdk_image_destroy(tmpimage);
g_free( fn );
nstones = image->rgb_width / STONE_SIZE;
/* ncolors = image->rgb_height / STONE_SIZE; */
ncolors = 3;
gtk_widget_draw (draw_area, NULL);
}
/*
\brief gets the displayed image (including the overlay plane)
and returns an RGBa image
*/
void vpDisplayGTK::getImage(vpImage<vpRGBa> &I)
{
// shoudl certainly be optimized.
// doesn't work
if (displayHasBeenInitialized)
{
GdkImage *ImageGtk;
/*
*/
ImageGtk = gdk_image_get(background, 0, 0, (gint)width, (gint)height);
I.resize(height,width) ;
guchar *pos;
guint32 pixel;
gint x,y;
guchar OctetRouge,OctetVert,OctetBleu,mask;
mask = 0x000000FF;
pos = (unsigned char *)I.bitmap;
for (y=0;y<(gint)height;y++)
{
for (x=0;x<(gint)width;x++)
{
pixel = gdk_image_get_pixel(ImageGtk,x,y);
OctetBleu = (guchar)pixel & mask;
OctetVert = (guchar)(pixel>>8) & mask;
OctetRouge = (guchar)(pixel>>16) & mask;
*pos++ = OctetRouge;
*pos++ = OctetVert;
*pos++ = OctetBleu;
*pos++ = 0;
}
}
}
else
{
/****************************************************************************
Converts a pixmap/mask sprite to a GdkPixbuf.
This is just a helper function for sprite_get_pixbuf(). Most callers
should use that function instead.
****************************************************************************/
static GdkPixbuf *gdk_pixbuf_new_from_pixmap_sprite(struct sprite *src)
{
GdkPixbuf *dst;
int w, h;
w = src->width;
h = src->height;
/* convert pixmap */
dst = gdk_pixbuf_new(GDK_COLORSPACE_RGB, src->mask != NULL, 8, w, h);
gdk_pixbuf_get_from_drawable(dst, src->pixmap, NULL, 0, 0, 0, 0, w, h);
/* convert mask */
if (src->mask) {
GdkImage *img;
int x, y, rowstride;
guchar *pixels;
img = gdk_drawable_get_image(src->mask, 0, 0, w, h);
pixels = gdk_pixbuf_get_pixels(dst);
rowstride = gdk_pixbuf_get_rowstride(dst);
for (y = 0; y < h; y++) {
for (x = 0; x < w; x++) {
guchar *pixel = pixels + y * rowstride + x * 4 + 3;
if (gdk_image_get_pixel(img, x, y)) {
*pixel = 255;
} else {
*pixel = 0;
}
}
}
g_object_unref(img);
}
return dst;
}
wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight, int newx, int newy )
{
wxCHECK_MSG( Ok(), wxNullBitmap, wxT("invalid bitmap") );
if (newy==M_BMPDATA->m_width && newy==M_BMPDATA->m_height)
return *this;
int width = wxMax(newx, 1);
int height = wxMax(newy, 1);
width = wxMin(width, clipwidth);
height = wxMin(height, clipheight);
wxBitmap bmp;
#ifdef __WXGTK20__
if (HasPixbuf())
{
bmp.SetWidth(width);
bmp.SetHeight(height);
bmp.SetDepth(GetDepth());
bmp.SetPixbuf(gdk_pixbuf_new(GDK_COLORSPACE_RGB,
gdk_pixbuf_get_has_alpha(GetPixbuf()),
8, width, height));
gdk_pixbuf_scale(GetPixbuf(), bmp.GetPixbuf(),
0, 0, width, height,
clipx, clipy,
(double)newx/GetWidth(), (double)newy/GetHeight(),
GDK_INTERP_BILINEAR);
}
else
#endif // __WXGTK20__
{
GdkImage *img = (GdkImage*) NULL;
if (GetPixmap())
img = gdk_image_get( GetPixmap(), 0, 0, GetWidth(), GetHeight() );
else if (GetBitmap())
img = gdk_image_get( GetBitmap(), 0, 0, GetWidth(), GetHeight() );
else
wxFAIL_MSG( wxT("Ill-formed bitmap") );
wxCHECK_MSG( img, wxNullBitmap, wxT("couldn't create image") );
int bpp = -1;
GdkGC *gc = NULL;
GdkPixmap *dstpix = NULL;
if (GetPixmap())
{
GdkVisual *visual = gdk_window_get_visual( GetPixmap() );
if (visual == NULL)
visual = wxTheApp->GetGdkVisual();
bpp = visual->depth;
bmp = wxBitmap(width,height,bpp);
dstpix = bmp.GetPixmap();
gc = gdk_gc_new( dstpix );
}
char *dst = NULL;
long dstbyteperline = 0;
if (GetBitmap())
{
bpp = 1;
dstbyteperline = width/8*M_BMPDATA->m_bpp;
if (width*M_BMPDATA->m_bpp % 8 != 0)
dstbyteperline++;
dst = (char*) malloc(dstbyteperline*height);
}
// be careful to use the right scaling factor
float scx = (float)M_BMPDATA->m_width/(float)newx;
float scy = (float)M_BMPDATA->m_height/(float)newy;
// prepare accel-tables
int *tablex = (int *)calloc(width,sizeof(int));
int *tabley = (int *)calloc(height,sizeof(int));
// accel table filled with clipped values
for (int x = 0; x < width; x++)
tablex[x] = (int) (scx * (x+clipx));
for (int y = 0; y < height; y++)
tabley[y] = (int) (scy * (y+clipy));
// Main rescaling routine starts here
for (int h = 0; h < height; h++)
{
char outbyte = 0;
int old_x = -1;
guint32 old_pixval = 0;
for (int w = 0; w < width; w++)
{
guint32 pixval;
int x = tablex[w];
if (x == old_x)
pixval = old_pixval;
else
{
pixval = gdk_image_get_pixel( img, x, tabley[h] );
old_pixval = pixval;
old_x = x;
}
if (bpp == 1)
{
if (!pixval)
{
char bit=1;
char shift = bit << w % 8;
outbyte |= shift;
}
if ((w+1)%8==0)
{
dst[h*dstbyteperline+w/8] = outbyte;
outbyte = 0;
}
}
else
{
GdkColor col;
col.pixel = pixval;
gdk_gc_set_foreground( gc, &col );
gdk_draw_point( dstpix, gc, w, h);
}
}
// do not forget the last byte
if ((bpp == 1) && (width % 8 != 0))
dst[h*dstbyteperline+width/8] = outbyte;
}
gdk_image_destroy( img );
if (gc) gdk_gc_unref( gc );
if (bpp == 1)
{
bmp = wxBitmap( (const char *)dst, width, height, 1 );
free( dst );
}
if (GetMask())
{
dstbyteperline = width/8;
if (width % 8 != 0)
dstbyteperline++;
dst = (char*) malloc(dstbyteperline*height);
img = gdk_image_get( GetMask()->GetBitmap(), 0, 0, GetWidth(), GetHeight() );
for (int h = 0; h < height; h++)
{
char outbyte = 0;
int old_x = -1;
guint32 old_pixval = 0;
for (int w = 0; w < width; w++)
{
guint32 pixval;
int x = tablex[w];
if (x == old_x)
pixval = old_pixval;
else
{
pixval = gdk_image_get_pixel( img, x, tabley[h] );
old_pixval = pixval;
old_x = x;
}
if (pixval)
{
char bit=1;
char shift = bit << w % 8;
outbyte |= shift;
}
if ((w+1)%8 == 0)
{
dst[h*dstbyteperline+w/8] = outbyte;
outbyte = 0;
}
}
// do not forget the last byte
if (width % 8 != 0)
dst[h*dstbyteperline+width/8] = outbyte;
}
wxMask* mask = new wxMask;
mask->m_bitmap = gdk_bitmap_create_from_data( wxGetRootWindow()->window, (gchar *) dst, width, height );
bmp.SetMask(mask);
free( dst );
gdk_image_destroy( img );
}
free( tablex );
free( tabley );
}
return bmp;
}
/****************************************************************************
Method returns the bounding box of a sprite. It assumes a rectangular
object/mask. The bounding box contains the border (pixel which have
unset pixel as neighbours) pixel.
****************************************************************************/
void sprite_get_bounding_box(struct sprite * sprite, int *start_x,
int *start_y, int *end_x, int *end_y)
{
GdkImage *mask_image;
GdkBitmap *mask = sprite_get_mask(sprite);
int i, j;
if (!mask) {
*start_x = 0;
*start_y = 0;
*end_x = sprite->width - 1;
*end_y = sprite->height - 1;
return;
}
mask_image
= gdk_drawable_get_image(mask, 0, 0, sprite->width, sprite->height);
/* parses mask image for the first column that contains a visible pixel */
*start_x = -1;
for (i = 0; i < sprite->width && *start_x == -1; i++) {
for (j = 0; j < sprite->height; j++) {
if (gdk_image_get_pixel(mask_image, i, j) != 0) {
*start_x = i;
break;
}
}
}
/* parses mask image for the last column that contains a visible pixel */
*end_x = -1;
for (i = sprite->width - 1; i >= *start_x && *end_x == -1; i--) {
for (j = 0; j < sprite->height; j++) {
if (gdk_image_get_pixel(mask_image, i, j) != 0) {
*end_x = i;
break;
}
}
}
/* parses mask image for the first row that contains a visible pixel */
*start_y = -1;
for (i = 0; i < sprite->height && *start_y == -1; i++) {
for (j = *start_x; j <= *end_x; j++) {
if (gdk_image_get_pixel(mask_image, j, i) != 0) {
*start_y = i;
break;
}
}
}
/* parses mask image for the last row that contains a visible pixel */
*end_y = -1;
for (i = sprite->height - 1; i >= *end_y && *end_y == -1; i--) {
for (j = *start_x; j <= *end_x; j++) {
if (gdk_image_get_pixel(mask_image, j, i) != 0) {
*end_y = i;
break;
}
}
}
g_object_unref(mask_image);
}
static void
psclipmask(GtkPlotPC *pc, gdouble x, gdouble y, const GdkBitmap *mask)
{
FILE *psout = GTK_PLOT_PS(pc)->psfile;
gint width, height;
gint px, py;
gint npoints = 0;
gint i;
GtkPlotVector *points;
GdkImage *image;
if(!mask){
fprintf(psout,"grestore\n");
return;
}
gdk_window_get_size((GdkWindow *)mask, &width, &height);
image = gdk_image_get((GdkWindow *)mask, 0, 0, width, height);
points = (GtkPlotVector *)g_malloc(width*height*sizeof(GtkPlotVector));
for(px = 0; px < width; px++){
for(py = 0; py < height; py++){
if(gdk_image_get_pixel(image, px, py)){
points[npoints].x = px;
points[npoints].y = py;
npoints++;
break;
}
}
}
for(py = points[npoints-1].y; py < height; py++){
for(px = width - 1; px >= 0; px--){
if(gdk_image_get_pixel(image, px, py)){
points[npoints].x = px;
points[npoints].y = py;
npoints++;
break;
}
}
}
for(px = points[npoints-1].x; px >= 0; px--){
for(py = height - 1; py >= 0; py--){
if(gdk_image_get_pixel(image, px, py)){
points[npoints].x = px;
points[npoints].y = py;
npoints++;
break;
}
}
}
for(py = points[npoints-1].y; py >= 0; py--){
for(px = 0; px < width; px++){
if(gdk_image_get_pixel(image, px, py)){
points[npoints].x = px;
points[npoints].y = py;
npoints++;
break;
}
}
}
fprintf(psout,"gsave\n");
fprintf(psout,"n\n");
fprintf(psout,"%g %g m\n", x + points[0].x, y + points[0].y);
for(i = 1; i < npoints; i++)
fprintf(psout,"%g %g l\n", x + points[i].x, y + points[i].y);
fprintf(psout,"cp\n");
fprintf(psout,"clip\n");
g_free(points);
gdk_image_destroy(image);
}
static GdkBitmap *
scale_bitmap (GdkWindow *window, GdkBitmap *bitmap, gdouble scale_x, gdouble scale_y)
{
GdkGC *gc;
GdkVisual *visual = NULL;
GdkImage *image = NULL, *new_image = NULL;
GdkBitmap *new_bitmap = NULL;
gint x, y, width, height, new_width, new_height;
GdkColor color;
if(!bitmap) return NULL;
if(!window) return NULL;
gc = gdk_gc_new(bitmap);
gdk_window_get_size(bitmap, &width, &height);
if(scale_x == 1.0 && scale_y == 1.0){
new_bitmap = gdk_pixmap_new(window, width, height, 1);
color.pixel = 0;
gdk_gc_set_foreground(gc, &color);
gdk_draw_rectangle(new_bitmap, gc, TRUE, 0, 0, width, height);
color.pixel = 1;
gdk_gc_set_foreground(gc, &color);
gdk_draw_pixmap(new_bitmap,
gc,
bitmap,
0, 0,
0, 0,
width, height);
gdk_gc_unref(gc);
return new_bitmap;
}
new_width = roundint(width * scale_x);
new_height = roundint(height * scale_y);
/* make a client side image of the bitmap, and
* scale the data into a another client side image */
visual = gdk_window_get_visual (bitmap);
if(!visual) return NULL;
new_image = gdk_image_new(GDK_IMAGE_FASTEST,visual,new_width,new_height);
if(!new_image) return NULL;
new_bitmap = gdk_pixmap_new(window, new_width, new_height, 1);
image = gdk_drawable_get_image(bitmap,
0, 0,
width, height);
color.pixel = 0;
gdk_gc_set_foreground(gc, &color);
gdk_draw_rectangle(new_bitmap, gc, TRUE, 0, 0, width, height);
color.pixel = 1;
gdk_gc_set_foreground(gc, &color);
for(x = 0; x < new_width; x++){
for(y = 0; y < new_height; y++){
gint px, py;
gulong pixel;
px = MIN(roundint(x / scale_x), width - 1);
py = MIN(roundint(y / scale_y), height - 1);
pixel = gdk_image_get_pixel(image, px, py);
gdk_image_put_pixel(new_image, x, y, pixel);
}
}
/* draw the image into a new pixmap */
gdk_draw_image(new_bitmap,gc,new_image,0,0,0,0,new_width,new_height);
gdk_image_destroy(image);
gdk_image_destroy(new_image);
gdk_gc_unref(gc);
return new_bitmap;
}
static void
gtk_plot_gdk_draw_string (GtkPlotPC *pc,
gint tx, gint ty,
gint angle,
const GdkColor *fg,
const GdkColor *bg,
gboolean transparent,
gint border,
gint border_space,
gint border_width,
gint shadow_width,
const gchar *font_name,
gint font_height,
GtkJustification just,
const gchar *text)
{
GdkBitmap *text_bitmap;
GdkPixmap *text_pixmap;
GdkBitmap *text_mask;
GdkImage *image;
GdkGC *gc, *bitmap_gc;
GdkColormap *colormap;
GdkColor white, black, mask_color;
GList *family = NULL;
gint y0;
gint old_width, old_height;
gboolean bold, italic;
gint fontsize;
gint ascent, descent;
gint numf;
gint xp = 0, yp = 0;
gint width, height;
gint x, y;
gint i;
GdkFont *font, *latin_font, *dfont;
GtkPSFont *psfont, *base_psfont, *latin_psfont;
gchar subs[2], insert_char;
GdkWChar *aux, *wtext, *lastchar = NULL, *xaux;
gchar num[4];
if(!GTK_PLOT_GDK(pc)->drawable) return;
if(!GTK_PLOT_GDK(pc)->window) return;
if(!GTK_PLOT_GDK(pc)->gc) return;
if(!text || strlen(text) == 0) return;
colormap = gdk_colormap_get_system ();
gc = GTK_PLOT_GDK(pc)->gc;
if(!gc) return;
gtk_plot_text_get_size(text, angle, font_name, font_height, &width, &height, &ascent, &descent);
if(height == 0 || width == 0) return;
old_width = width;
old_height = height;
if(angle == 90 || angle == 270)
{
old_width = height;
old_height = width;
}
gtk_psfont_get_families(&family, &numf);
font = gtk_psfont_get_gdkfont(font_name, font_height);
base_psfont = psfont = gtk_psfont_get_font(font_name);
italic = psfont->italic;
bold = psfont->bold;
fontsize = font_height;
x = 0;
y0 = y = ascent;
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily, italic,
bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname, fontsize);
} else {
latin_psfont = NULL;
latin_font = NULL;
}
i = strlen(text) + 2;
aux = wtext = g_malloc0(sizeof(GdkWChar) * i);
gdk_mbstowcs(wtext, text, i - 1);
/* initializing text bitmap - ajd */
text_bitmap = gdk_pixmap_new(GTK_PLOT_GDK(pc)->window,
old_width, old_height, 1);
bitmap_gc = gdk_gc_new(text_bitmap);
gdk_color_white (colormap, &white);
gdk_gc_set_foreground(bitmap_gc, &white);
gdk_draw_rectangle(text_bitmap, bitmap_gc, TRUE,
0, 0, -1, -1);
gdk_color_black (colormap, &black);
gdk_gc_set_foreground(bitmap_gc, &black);
while(aux && *aux != '\0' && *aux != '\n'){
if(*aux == '\\'){
aux++;
switch(*aux){
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7': case '9':
psfont = gtk_psfont_find_by_family((gchar *)g_list_nth_data(family, *aux-'0'), italic, bold);
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
aux++;
break;
case '8': case 'g':
psfont = gtk_psfont_find_by_family("Symbol", italic, bold);
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
aux++;
break;
case 'B':
bold = TRUE;
psfont = gtk_psfont_find_by_family(psfont->family, italic, bold);
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily,
italic, bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname,
fontsize);
}
aux++;
break;
case 'x':
xaux = aux + 1;
for (i=0; i<3; i++){
if (xaux[i] >= '0' && xaux[i] <= '9')
num[i] = xaux[i];
else
break;
}
if (i < 3){
aux++;
break;
}
num[3] = '\0';
insert_char = (gchar)atoi(num);
subs[0] = insert_char;
subs[1] = '\0';
/* \xNNN is always outputted with latin fonts. */
dfont = (psfont->i18n_latinfamily != NULL) ? latin_font : font;
gdk_draw_string (text_bitmap, dfont,
bitmap_gc,
x, y,
subs);
x += gdk_char_width(font, insert_char);
aux += 4;
lastchar = aux - 1;
break;
case 'i':
italic = TRUE;
psfont = gtk_psfont_find_by_family(psfont->family, italic, bold);
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily,
italic, bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname,
fontsize);
}
aux++;
break;
case 'S': case '^':
fontsize = (int)((gdouble)fontsize * 0.6 + 0.5);
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
y -= font->ascent;
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily,
italic, bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname,
fontsize);
}
aux++;
break;
case 's': case '_':
fontsize = (int)((gdouble)fontsize * 0.6 + 0.5);
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
y += font->descent;
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily,
italic, bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname,
fontsize);
}
aux++;
break;
case '+':
fontsize += 3;
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily,
italic, bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname,
fontsize);
}
aux++;
break;
case '-':
fontsize -= 3;
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily,
italic, bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname,
fontsize);
}
aux++;
break;
case 'N':
psfont = base_psfont;
gdk_font_unref(font);
fontsize = font_height;
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
y = y0;
italic = psfont->italic;
bold = psfont->bold;
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily,
italic, bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname,
fontsize);
}
aux++;
break;
case 'b':
if (lastchar) {
gtk_psfont_get_char_size(psfont, font, latin_font, *lastchar, &i,
NULL, NULL);
x -= i;
if (lastchar == wtext)
lastchar = NULL;
else
lastchar--;
} else {
gtk_psfont_get_char_size(psfont, font, latin_font, 'X', &i, NULL,
NULL);
x -= i;
}
aux++;
break;
default:
if(aux && *aux != '\0' && *aux !='\n'){
x += drawstring(pc, text_bitmap, bitmap_gc, &black, &white, x, y,
psfont, font, latin_font, *aux);
lastchar = aux;
aux++;
}
break;
}
} else {
if(aux && *aux != '\0' && *aux !='\n'){
x += drawstring(pc, text_bitmap, bitmap_gc, &black, &white, x, y,
psfont, font, latin_font, *aux);
lastchar = aux;
aux++;
}
}
}
g_free(wtext);
/* initializing clip mask bitmap - ajd */
text_mask = gdk_pixmap_new(GTK_PLOT_GDK(pc)->window, width, height, 1);
mask_color = white;
mask_color.pixel = 0;
gdk_gc_set_foreground(bitmap_gc, &mask_color);
gdk_draw_rectangle(text_mask, bitmap_gc, TRUE, 0, 0, -1, -1);
mask_color = black;
mask_color.pixel = 1;
gdk_gc_set_foreground(bitmap_gc, &mask_color);
/* performing text rotation and saving it onto clip mask bitmap - ajd */
image = gdk_image_get(text_bitmap, 0, 0, old_width, old_height);
for(y = 0; y < old_height; y++)
for(x = 0; x < old_width; x++)
{
if( black.pixel == gdk_image_get_pixel(image, x, y) ){
switch(angle){
case 0:
xp = x;
yp = y;
break;
case 90:
xp = y;
yp = old_width - x;
break;
case 180:
xp = old_width - x;
yp = old_height - y;
break;
case 270:
xp = old_height - y;
yp = x;
break;
}
gdk_draw_point(text_mask, bitmap_gc, xp, yp);
}
}
gdk_image_destroy(image);
/* initializing text pixmap - ajd */
text_pixmap = gdk_pixmap_new(GTK_PLOT_GDK(pc)->window, width, height, -1);
gdk_gc_set_foreground(gc, (GdkColor *) bg);
gdk_draw_rectangle(text_pixmap, gc, TRUE, 0, 0, -1, -1);
gdk_gc_set_foreground(gc, (GdkColor *) fg);
/* copying clip mask bitmap onto text pixmap - ajd */
gdk_gc_set_clip_mask(gc, text_mask);
gdk_gc_set_clip_origin(gc, 0, 0);
gdk_draw_rectangle(text_pixmap, gc, TRUE, 0, 0, -1, -1);
gdk_gc_set_clip_mask(gc, NULL);
gtk_plot_text_get_area(text, angle, just, font_name, font_height,
&x, &y, &width, &height);
tx += x;
ty += y;
if(transparent){
gdk_gc_set_clip_mask (gc, text_mask);
gdk_gc_set_clip_origin (gc, tx, ty);
} else {
gdk_gc_set_foreground(gc, (GdkColor *) bg);
gtk_plot_pc_draw_rectangle(pc,
TRUE,
tx - border_space, ty - border_space,
width + 2*border_space, height + 2*border_space);
}
gdk_draw_pixmap(GTK_PLOT_GDK(pc)->drawable, gc,
text_pixmap, 0, 0,
tx, ty, -1, -1);
gdk_gc_set_clip_mask(gc, NULL);
gdk_pixmap_unref(text_pixmap);
gdk_bitmap_unref(text_mask);
gdk_font_unref(font);
if (latin_font) gdk_font_unref(latin_font);
gdk_gc_unref(bitmap_gc);
gdk_pixmap_unref(text_bitmap);
/* border */
gdk_gc_set_foreground(gc, (GdkColor *) fg);
gtk_plot_pc_set_dash(pc, 0, NULL, 0);
gtk_plot_pc_set_lineattr(pc, border_width, 0, 0, 0);
switch(border){
case GTK_PLOT_BORDER_SHADOW:
gtk_plot_pc_draw_rectangle(pc,
TRUE,
tx - border_space + shadow_width,
ty + height + border_space,
width + 2 * border_space, shadow_width);
gtk_plot_pc_draw_rectangle(pc,
TRUE,
tx + width + border_space,
ty - border_space + shadow_width,
shadow_width, height + 2 * border_space);
case GTK_PLOT_BORDER_LINE:
gtk_plot_pc_draw_rectangle(pc,
FALSE,
tx - border_space, ty - border_space,
width + 2*border_space, height + 2*border_space);
case GTK_PLOT_BORDER_NONE:
default:
break;
}
return;
}
/* subfunction of gtk_plot_gdk_draw_string(). */
static gint
drawstring(GtkPlotPC *pc,
GdkBitmap *dest,
GdkGC *gc,
GdkColor *black, GdkColor *white,
gint dx, gint dy,
GtkPSFont *psfont,
GdkFont *font,
GdkFont *latin_font,
GdkWChar wc)
{
GdkBitmap *tmp;
GdkFont *dfont;
GdkImage *image;
gint w, h, a, d, x, y, d2;
guint32 pixel;
if (psfont->i18n_latinfamily && psfont->vertical && (0 > wc || wc > 0x7f)) {
/* vertical-writing CJK postscript fonts. */
dfont = font;
w = gdk_char_width_wc(dfont, wc);
a = dfont->ascent;
d = dfont->descent;
h = a + d;
d2 = w * d / h;
tmp = gdk_pixmap_new(GTK_PLOT_GDK(pc)->window, w, h, 1);
gdk_gc_set_foreground(gc, white);
gdk_draw_rectangle(tmp, gc, TRUE, 0, 0, -1, -1);
gdk_gc_set_foreground(gc, black);
gdk_draw_text_wc(tmp, dfont, gc, 0, a, &wc, 1);
image = gdk_image_get(tmp, 0, 0, w, h);
for (y = 0; y < h; y++) {
for (x = 0; x < w; x++) {
pixel = gdk_image_get_pixel(image, x, y);
if (pixel == black->pixel)
gdk_draw_point(dest, gc, dx + y, dy + d2 - x);
}
}
gdk_image_destroy(image);
gdk_pixmap_unref(tmp);
return h;
} else {
/* horizontal writing */
if (psfont->i18n_latinfamily && 0 <= wc && wc <= 0x7f)
dfont = latin_font;
else
dfont = font;
gdk_draw_text_wc(dest, dfont, gc, dx, dy, &wc, 1);
w = gdk_char_width_wc(dfont, wc);
return w;
}
}
static VALUE
rg_get_pixel(VALUE self, VALUE x, VALUE y)
{
return INT2NUM(gdk_image_get_pixel(_SELF(self),
NUM2INT(x), NUM2INT(y)));
}