X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=render%2Frender.c;h=fd442d26b40bc43b83e074fa120cc1060437ca55;hb=4c7cc1cfa64bf5722f059eae0528d510c2ae636f;hp=b2575c634683a16634a75a2407ad23ea2f48cac3;hpb=cd12a2eae5b5b72df08d588ac71d1f6cf6725dfb;p=chaz%2Fopenbox diff --git a/render/render.c b/render/render.c index b2575c63..fd442d26 100644 --- a/render/render.c +++ b/render/render.c @@ -1,7 +1,23 @@ -#include -#include +/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*- + + render.c for the Openbox window manager + Copyright (c) 2006 Mikael Magnusson + Copyright (c) 2003-2007 Dana Jansens + Copyright (c) 2003 Derek Foreman + + 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. + + See the COPYING file for a copy of the GNU General Public License. +*/ -#include #include "render.h" #include "gradient.h" #include "font.h" @@ -9,300 +25,212 @@ #include "color.h" #include "image.h" #include "theme.h" -#include "kernel/openbox.h" + +#include +#include +#include +#include #ifdef HAVE_STDLIB_H # include #endif -int render_depth; -XVisualInfo render_visual_info; - -Visual *render_visual; -Colormap render_colormap; - -int render_red_offset = 0, render_green_offset = 0, render_blue_offset = 0; -int render_red_shift, render_green_shift, render_blue_shift; -int render_red_mask, render_green_mask, render_blue_mask; +static void pixel_data_to_pixmap(RrAppearance *l, + gint x, gint y, gint w, gint h); - -void render_startup(void) +Pixmap RrPaintPixmap(RrAppearance *a, gint w, gint h) { - render_depth = DefaultDepth(ob_display, ob_screen); - render_visual = DefaultVisual(ob_display, ob_screen); - render_colormap = DefaultColormap(ob_display, ob_screen); + gint i, transferred = 0, force_transfer = 0; + Pixmap oldp = None; + RrRect tarea; /* area in which to draw textures */ + gboolean resized; - switch (render_visual->class) { - case TrueColor: - truecolor_startup(); - break; - case PseudoColor: - case StaticColor: - case GrayScale: - case StaticGray: - pseudocolor_startup(); - break; - default: - g_critical("unsupported visual class.\n"); - exit(EXIT_FAILURE); - } -} + if (w <= 0 || h <= 0) return None; -void truecolor_startup(void) -{ - unsigned long red_mask, green_mask, blue_mask; - XImage *timage = NULL; - - timage = XCreateImage(ob_display, render_visual, render_depth, - ZPixmap, 0, NULL, 1, 1, 32, 0); - g_assert(timage != NULL); - /* find the offsets for each color in the visual's masks */ - render_red_mask = red_mask = timage->red_mask; - render_green_mask = green_mask = timage->green_mask; - render_blue_mask = blue_mask = timage->blue_mask; - - render_red_offset = 0; - render_green_offset = 0; - render_blue_offset = 0; - - while (! (red_mask & 1)) { render_red_offset++; red_mask >>= 1; } - while (! (green_mask & 1)) { render_green_offset++; green_mask >>= 1; } - while (! (blue_mask & 1)) { render_blue_offset++; blue_mask >>= 1; } - - render_red_shift = render_green_shift = render_blue_shift = 8; - while (red_mask) { red_mask >>= 1; render_red_shift--; } - while (green_mask) { green_mask >>= 1; render_green_shift--; } - while (blue_mask) { blue_mask >>= 1; render_blue_shift--; } - XFree(timage); -} + if (a->surface.parentx < 0 || a->surface.parenty < 0) { + /* ob_debug("Invalid parent co-ordinates\n"); */ + return None; + } -void pseudocolor_startup(void) -{ - XColor icolors[256]; - int tr, tg, tb, n, r, g, b, i, incolors, ii; - unsigned long dev; - int cpc, _ncolors; - g_message("Initializing PseudoColor RenderControl\n"); - - /* determine the number of colors and the bits-per-color */ - pseudo_bpc = 2; /* XXX THIS SHOULD BE A USER OPTION */ - g_assert(pseudo_bpc >= 1); - _ncolors = pseudo_ncolors(); - - if (_ncolors > 1 << render_depth) { - g_warning("PseudoRenderControl: Invalid colormap size. Resizing.\n"); - pseudo_bpc = 1 << (render_depth/3) >> 3; - _ncolors = 1 << (pseudo_bpc * 3); - } - - /* build a color cube */ - pseudo_colors = malloc(_ncolors * sizeof(XColor)); - cpc = 1 << pseudo_bpc; /* colors per channel */ - - for (n = 0, r = 0; r < cpc; r++) - for (g = 0; g < cpc; g++) - for (b = 0; b < cpc; b++, n++) { - tr = (int)(((float)(r)/(float)(cpc-1)) * 0xFF); - tg = (int)(((float)(g)/(float)(cpc-1)) * 0xFF); - tb = (int)(((float)(b)/(float)(cpc-1)) * 0xFF); - pseudo_colors[n].red = tr | tr << 8; - pseudo_colors[n].green = tg | tg << 8; - pseudo_colors[n].blue = tb | tb << 8; - pseudo_colors[n].flags = DoRed|DoGreen|DoBlue; /* used to track - allocation */ - } - - /* allocate the colors */ - for (i = 0; i < _ncolors; i++) - if (!XAllocColor(ob_display, render_colormap, &pseudo_colors[i])) - pseudo_colors[i].flags = 0; /* mark it as unallocated */ - - /* try allocate any colors that failed allocation above */ - - /* get the allocated values from the X server (only the first 256 XXX why!?) - */ - incolors = (((1 << render_depth) > 256) ? 256 : (1 << render_depth)); - for (i = 0; i < incolors; i++) - icolors[i].pixel = i; - XQueryColors(ob_display, render_colormap, icolors, incolors); - - /* try match unallocated ones */ - for (i = 0; i < _ncolors; i++) { - if (!pseudo_colors[i].flags) { /* if it wasn't allocated... */ - unsigned long closest = 0xffffffff, close = 0; - for (ii = 0; ii < incolors; ii++) { - /* find deviations */ - r = (pseudo_colors[i].red - icolors[ii].red) & 0xff; - g = (pseudo_colors[i].green - icolors[ii].green) & 0xff; - b = (pseudo_colors[i].blue - icolors[ii].blue) & 0xff; - /* find a weighted absolute deviation */ - dev = (r * r) + (g * g) + (b * b); - - if (dev < closest) { - closest = dev; - close = ii; - } - } - - pseudo_colors[i].red = icolors[close].red; - pseudo_colors[i].green = icolors[close].green; - pseudo_colors[i].blue = icolors[close].blue; - pseudo_colors[i].pixel = icolors[close].pixel; - - /* try alloc this closest color, it had better succeed! */ - if (XAllocColor(ob_display, render_colormap, &pseudo_colors[i])) - pseudo_colors[i].flags = DoRed|DoGreen|DoBlue; /* mark as alloced */ - else - g_assert(FALSE); /* wtf has gone wrong, its already alloced for - chissake! */ + if (a->surface.grad == RR_SURFACE_PARENTREL && + (a->surface.parentx >= a->surface.parent->w || + a->surface.parenty >= a->surface.parent->h)) + { + return None; } - } -} -void paint(Window win, Appearance *l, int w, int h) -{ - int i, transferred = 0, sw; - pixel32 *source, *dest; - Pixmap oldp; - Rect tarea; /* area in which to draw textures */ - gboolean resized; + resized = (a->w != w || a->h != h); - if (w <= 0 || h <= 0) return; + oldp = a->pixmap; /* save to free after changing the visible pixmap */ + a->pixmap = XCreatePixmap(RrDisplay(a->inst), + RrRootWindow(a->inst), + w, h, RrDepth(a->inst)); - resized = (l->w != w || l->h != h); + g_assert(a->pixmap != None); + a->w = w; + a->h = h; + + if (a->xftdraw != NULL) + XftDrawDestroy(a->xftdraw); + a->xftdraw = XftDrawCreate(RrDisplay(a->inst), a->pixmap, + RrVisual(a->inst), RrColormap(a->inst)); + g_assert(a->xftdraw != NULL); if (resized) { - oldp = l->pixmap; /* save to free after changing the visible pixmap */ - l->pixmap = XCreatePixmap(ob_display, ob_root, w, h, render_depth); - } else - oldp = None; - - g_assert(l->pixmap != None); - l->w = w; - l->h = h; - - if (l->xftdraw != NULL) - XftDrawDestroy(l->xftdraw); - l->xftdraw = XftDrawCreate(ob_display, l->pixmap, render_visual, - render_colormap); - g_assert(l->xftdraw != NULL); - - g_free(l->surface.pixel_data); - l->surface.pixel_data = g_new(pixel32, w * h); - - if (l->surface.grad == Background_ParentRelative) { - g_assert (l->surface.parent); - g_assert (l->surface.parent->w); - - sw = l->surface.parent->w; - source = (l->surface.parent->surface.pixel_data + l->surface.parentx + - sw * l->surface.parenty); - dest = l->surface.pixel_data; - for (i = 0; i < h; i++, source += sw, dest += w) { - memcpy(dest, source, w * sizeof(pixel32)); - } + g_free(a->surface.pixel_data); + a->surface.pixel_data = g_new(RrPixel32, w * h); } - else if (l->surface.grad == Background_Solid) - gradient_solid(l, 0, 0, w, h); - else gradient_render(&l->surface, w, h); - - RECT_SET(tarea, 0, 0, w, h); - if (l->surface.grad != Background_ParentRelative) { - if (l->surface.relief != Flat) { - switch (l->surface.bevel) { - case Bevel1: - tarea.x += 1; tarea.y += 1; - tarea.width -= 2; tarea.height -= 2; - break; - case Bevel2: - tarea.x += 2; tarea.y += 2; - tarea.width -= 4; tarea.height -= 4; - break; - } - } else if (l->surface.border) { - tarea.x += 1; tarea.y += 1; - tarea.width -= 2; tarea.height -= 2; - } + + RrRender(a, w, h); + + { + gint l, t, r, b; + RrMargins(a, &l, &t, &r, &b); + RECT_SET(tarea, l, t, w - l - r, h - t - b); } - for (i = 0; i < l->textures; i++) { - switch (l->texture[i].type) { - case NoTexture: + for (i = 0; i < a->textures; i++) { + switch (a->texture[i].type) { + case RR_TEXTURE_NONE: break; - case Text: + case RR_TEXTURE_TEXT: if (!transferred) { transferred = 1; - if (l->surface.grad != Background_Solid) - pixel32_to_pixmap(l->surface.pixel_data, - l->pixmap, 0, 0, w, h); + if ((a->surface.grad != RR_SURFACE_SOLID) + || (a->surface.interlaced)) + pixel_data_to_pixmap(a, 0, 0, w, h); } - if (l->xftdraw == NULL) { - l->xftdraw = XftDrawCreate(ob_display, l->pixmap, - render_visual, render_colormap); + if (a->xftdraw == NULL) { + a->xftdraw = XftDrawCreate(RrDisplay(a->inst), a->pixmap, + RrVisual(a->inst), + RrColormap(a->inst)); } - font_draw(l->xftdraw, &l->texture[i].data.text, &tarea); - break; - case Bitmask: + RrFontDraw(a->xftdraw, &a->texture[i].data.text, &tarea); + break; + case RR_TEXTURE_LINE_ART: if (!transferred) { transferred = 1; - if (l->surface.grad != Background_Solid) - pixel32_to_pixmap(l->surface.pixel_data, - l->pixmap, 0, 0, w, h); + if ((a->surface.grad != RR_SURFACE_SOLID) + || (a->surface.interlaced)) + pixel_data_to_pixmap(a, 0, 0, w, h); } - if (l->texture[i].data.mask.color->gc == None) - color_allocate_gc(l->texture[i].data.mask.color); - mask_draw(l->pixmap, &l->texture[i].data.mask, &tarea); - break; - case RGBA: - image_draw(l->surface.pixel_data, - &l->texture[i].data.rgba, &tarea); + XDrawLine(RrDisplay(a->inst), a->pixmap, + RrColorGC(a->texture[i].data.lineart.color), + a->texture[i].data.lineart.x1, + a->texture[i].data.lineart.y1, + a->texture[i].data.lineart.x2, + a->texture[i].data.lineart.y2); + break; + case RR_TEXTURE_MASK: + if (!transferred) { + transferred = 1; + if ((a->surface.grad != RR_SURFACE_SOLID) + || (a->surface.interlaced)) + pixel_data_to_pixmap(a, 0, 0, w, h); + } + RrPixmapMaskDraw(a->pixmap, &a->texture[i].data.mask, &tarea); + break; + case RR_TEXTURE_IMAGE: + g_assert(!transferred); + { + RrRect narea = tarea; + RrTextureImage *img = &a->texture[i].data.image; + if (img->twidth) + narea.width = MIN(tarea.width, img->twidth); + if (img->theight) + narea.height = MIN(tarea.height, img->theight); + narea.x += img->tx; + narea.y += img->ty; + RrImageDrawImage(a->surface.pixel_data, + &a->texture[i].data.image, + a->w, a->h, + &narea); + } + force_transfer = 1; + break; + case RR_TEXTURE_RGBA: + g_assert(!transferred); + { + RrRect narea = tarea; + RrTextureRGBA *rgb = &a->texture[i].data.rgba; + if (rgb->twidth) + narea.width = MIN(tarea.width, rgb->twidth); + if (rgb->theight) + narea.height = MIN(tarea.height, rgb->theight); + narea.x += rgb->tx; + narea.y += rgb->ty; + RrImageDrawRGBA(a->surface.pixel_data, + &a->texture[i].data.rgba, + a->w, a->h, + &narea); + } + force_transfer = 1; break; } } if (!transferred) { transferred = 1; - if (l->surface.grad != Background_Solid) - pixel32_to_pixmap(l->surface.pixel_data, l->pixmap, 0, 0, w, h); + if ((a->surface.grad != RR_SURFACE_SOLID) || (a->surface.interlaced) || + force_transfer) + { + pixel_data_to_pixmap(a, 0, 0, w, h); + } } - - XSetWindowBackgroundPixmap(ob_display, win, l->pixmap); - XClearWindow(ob_display, win); - if (oldp) XFreePixmap(ob_display, oldp); + return oldp; } -void render_shutdown(void) +void RrPaint(RrAppearance *a, Window win, gint w, gint h) { + Pixmap oldp; + + oldp = RrPaintPixmap(a, w, h); + XSetWindowBackgroundPixmap(RrDisplay(a->inst), win, a->pixmap); + XClearWindow(RrDisplay(a->inst), win); + /* free this after changing the visible pixmap */ + if (oldp) XFreePixmap(RrDisplay(a->inst), oldp); } -Appearance *appearance_new(int numtex) +RrAppearance *RrAppearanceNew(const RrInstance *inst, gint numtex) { - Surface *p; - Appearance *out; + RrAppearance *out; - out = g_new(Appearance, 1); + out = g_new0(RrAppearance, 1); + out->inst = inst; out->textures = numtex; - out->xftdraw = NULL; - if (numtex) out->texture = g_new0(Texture, numtex); - else out->texture = NULL; - out->pixmap = None; - out->w = out->h = 0; - - p = &out->surface; - p->primary = NULL; - p->secondary = NULL; - p->border_color = NULL; - p->bevel_dark = NULL; - p->bevel_light = NULL; - p->pixel_data = NULL; + out->surface.bevel_light_adjust = 128; + out->surface.bevel_dark_adjust = 64; + if (numtex) out->texture = g_new0(RrTexture, numtex); + return out; } -Appearance *appearance_copy(Appearance *orig) +void RrAppearanceRemoveTextures(RrAppearance *a) { - Surface *spo, *spc; - Appearance *copy = g_new(Appearance, 1); + g_free(a->texture); + a->textures = 0; +} + +void RrAppearanceAddTextures(RrAppearance *a, gint numtex) +{ + g_assert(a->textures == 0); + + a->textures = numtex; + if (numtex) a->texture = g_new0(RrTexture, numtex); +} + +void RrAppearanceClearTextures(RrAppearance *a) +{ + memset(a->texture, 0, a->textures * sizeof(RrTexture)); +} + +RrAppearance *RrAppearanceCopy(RrAppearance *orig) +{ + RrSurface *spo, *spc; + RrAppearance *copy = g_new(RrAppearance, 1); + + copy->inst = orig->inst; spo = &(orig->surface); spc = &(copy->surface); @@ -310,170 +238,305 @@ Appearance *appearance_copy(Appearance *orig) spc->relief = spo->relief; spc->bevel = spo->bevel; if (spo->primary != NULL) - spc->primary = color_new(spo->primary->r, - spo->primary->g, - spo->primary->b); + spc->primary = RrColorNew(copy->inst, + spo->primary->r, + spo->primary->g, + spo->primary->b); else spc->primary = NULL; if (spo->secondary != NULL) - spc->secondary = color_new(spo->secondary->r, - spo->secondary->g, - spo->secondary->b); + spc->secondary = RrColorNew(copy->inst, + spo->secondary->r, + spo->secondary->g, + spo->secondary->b); else spc->secondary = NULL; if (spo->border_color != NULL) - spc->border_color = color_new(spo->border_color->r, - spo->border_color->g, - spo->border_color->b); + spc->border_color = RrColorNew(copy->inst, + spo->border_color->r, + spo->border_color->g, + spo->border_color->b); else spc->border_color = NULL; + if (spo->interlace_color != NULL) + spc->interlace_color = RrColorNew(copy->inst, + spo->interlace_color->r, + spo->interlace_color->g, + spo->interlace_color->b); + else spc->interlace_color = NULL; + if (spo->bevel_dark != NULL) - spc->bevel_dark = color_new(spo->bevel_dark->r, - spo->bevel_dark->g, - spo->bevel_dark->b); + spc->bevel_dark = RrColorNew(copy->inst, + spo->bevel_dark->r, + spo->bevel_dark->g, + spo->bevel_dark->b); else spc->bevel_dark = NULL; if (spo->bevel_light != NULL) - spc->bevel_light = color_new(spo->bevel_light->r, - spo->bevel_light->g, - spo->bevel_light->b); + spc->bevel_light = RrColorNew(copy->inst, + spo->bevel_light->r, + spo->bevel_light->g, + spo->bevel_light->b); else spc->bevel_light = NULL; + if (spo->split_primary != NULL) + spc->split_primary = RrColorNew(copy->inst, + spo->split_primary->r, + spo->split_primary->g, + spo->split_primary->b); + else spc->split_primary = NULL; + + if (spo->split_secondary != NULL) + spc->split_secondary = RrColorNew(copy->inst, + spo->split_secondary->r, + spo->split_secondary->g, + spo->split_secondary->b); + else spc->split_secondary = NULL; + spc->interlaced = spo->interlaced; + spc->bevel_light_adjust = spo->bevel_light_adjust; + spc->bevel_dark_adjust = spo->bevel_dark_adjust; spc->border = spo->border; + spc->parent = NULL; + spc->parentx = spc->parenty = 0; spc->pixel_data = NULL; copy->textures = orig->textures; - copy->texture = g_memdup(orig->texture, orig->textures * sizeof(Texture)); + copy->texture = g_memdup(orig->texture, + orig->textures * sizeof(RrTexture)); copy->pixmap = None; copy->xftdraw = NULL; copy->w = copy->h = 0; return copy; } -void appearance_free(Appearance *a) +void RrAppearanceFree(RrAppearance *a) { if (a) { - Surface *p; - if (a->pixmap != None) XFreePixmap(ob_display, a->pixmap); + RrSurface *p; + if (a->pixmap != None) XFreePixmap(RrDisplay(a->inst), a->pixmap); if (a->xftdraw != NULL) XftDrawDestroy(a->xftdraw); if (a->textures) g_free(a->texture); p = &a->surface; - color_free(p->primary); - color_free(p->secondary); - color_free(p->border_color); - color_free(p->bevel_dark); - color_free(p->bevel_light); + RrColorFree(p->primary); + RrColorFree(p->secondary); + RrColorFree(p->border_color); + RrColorFree(p->interlace_color); + RrColorFree(p->bevel_dark); + RrColorFree(p->bevel_light); + RrColorFree(p->split_primary); + RrColorFree(p->split_secondary); g_free(p->pixel_data); - + p->pixel_data = NULL; g_free(a); } } -void pixel32_to_pixmap(pixel32 *in, Pixmap out, int x, int y, int w, int h) +static void pixel_data_to_pixmap(RrAppearance *l, + gint x, gint y, gint w, gint h) { - pixel32 *scratch; + RrPixel32 *in, *scratch; + Pixmap out; XImage *im = NULL; - im = XCreateImage(ob_display, render_visual, render_depth, + im = XCreateImage(RrDisplay(l->inst), RrVisual(l->inst), RrDepth(l->inst), ZPixmap, 0, NULL, w, h, 32, 0); g_assert(im != NULL); - im->byte_order = render_endian; + + in = l->surface.pixel_data; + out = l->pixmap; + /* this malloc is a complete waste of time on normal 32bpp as reduce_depth just sets im->data = data and returns */ - scratch = g_new(pixel32, im->width * im->height); - im->data = (char*) scratch; - reduce_depth(in, im); - XPutImage(ob_display, out, DefaultGC(ob_display, ob_screen), + scratch = g_new(RrPixel32, im->width * im->height); + im->data = (gchar*) scratch; + RrReduceDepth(l->inst, in, im); + XPutImage(RrDisplay(l->inst), out, + DefaultGC(RrDisplay(l->inst), RrScreen(l->inst)), im, 0, 0, x, y, w, h); im->data = NULL; XDestroyImage(im); g_free(scratch); } -void appearance_minsize(Appearance *l, int *w, int *h) +void RrMargins (RrAppearance *a, gint *l, gint *t, gint *r, gint *b) +{ + *l = *t = *r = *b = 0; + + if (a->surface.grad != RR_SURFACE_PARENTREL) { + if (a->surface.relief != RR_RELIEF_FLAT) { + switch (a->surface.bevel) { + case RR_BEVEL_1: + *l = *t = *r = *b = 1; + break; + case RR_BEVEL_2: + *l = *t = *r = *b = 2; + break; + } + } else if (a->surface.border) { + *l = *t = *r = *b = 1; + } + } +} + +void RrMinSize(RrAppearance *a, gint *w, gint *h) { - int i; - int m; - *w = *h = 0; - - for (i = 0; i < l->textures; ++i) { - switch (l->texture[i].type) { - case Bitmask: - *w = MAX(*w, l->texture[i].data.mask.mask->w); - *h = MAX(*h, l->texture[i].data.mask.mask->h); + *w = RrMinWidth(a); + *h = RrMinHeight(a); +} + +gint RrMinWidth(RrAppearance *a) +{ + gint i; + RrSize *m; + gint l, t, r, b; + gint w = 0; + + RrMargins(a, &l, &t, &r, &b); + + for (i = 0; i < a->textures; ++i) { + switch (a->texture[i].type) { + case RR_TEXTURE_NONE: + break; + case RR_TEXTURE_MASK: + w = MAX(w, a->texture[i].data.mask.mask->width); + break; + case RR_TEXTURE_TEXT: + m = RrFontMeasureString(a->texture[i].data.text.font, + a->texture[i].data.text.string, + a->texture[i].data.text.shadow_offset_x, + a->texture[i].data.text.shadow_offset_y, + a->texture[i].data.text.flow, + a->texture[i].data.text.maxwidth); + w = MAX(w, m->width); + g_free(m); break; - case Text: - m = font_measure_string(l->texture[i].data.text.font, - l->texture[i].data.text.string, - l->texture[i].data.text.shadow, - l->texture[i].data.text.offset); - *w = MAX(*w, m); - m = font_height(l->texture[i].data.text.font, - l->texture[i].data.text.shadow, - l->texture[i].data.text.offset); - *h += MAX(*h, m); + case RR_TEXTURE_RGBA: + w += MAX(w, a->texture[i].data.rgba.width); break; - case RGBA: - *w += MAX(*w, l->texture[i].data.rgba.width); - *h += MAX(*h, l->texture[i].data.rgba.height); + case RR_TEXTURE_IMAGE: + /* images resize so they don't contribute anything to the min */ break; - case NoTexture: + case RR_TEXTURE_LINE_ART: + w = MAX(w, MAX(a->texture[i].data.lineart.x1 - l - r, + a->texture[i].data.lineart.x2 - l - r)); break; } } - if (l->surface.relief != Flat) { - switch (l->surface.bevel) { - case Bevel1: - *w += 2; - *h += 2; + w += l + r; + + if (w < 1) w = 1; + return w; +} + +gint RrMinHeight(RrAppearance *a) +{ + gint i; + gint l, t, r, b; + RrSize *m; + gint h = 0; + + RrMargins(a, &l, &t, &r, &b); + + for (i = 0; i < a->textures; ++i) { + switch (a->texture[i].type) { + case RR_TEXTURE_NONE: break; - case Bevel2: - *w += 4; - *h += 4; + case RR_TEXTURE_MASK: + h = MAX(h, a->texture[i].data.mask.mask->height); + break; + case RR_TEXTURE_TEXT: + if (a->texture[i].data.text.flow) { + g_assert(a->texture[i].data.text.string != NULL); + + m = RrFontMeasureString + (a->texture[i].data.text.font, + a->texture[i].data.text.string, + a->texture[i].data.text.shadow_offset_x, + a->texture[i].data.text.shadow_offset_y, + a->texture[i].data.text.flow, + a->texture[i].data.text.maxwidth); + h += MAX(h, m->height); + g_free(m); + } + else + h += MAX(h, + RrFontHeight + (a->texture[i].data.text.font, + a->texture[i].data.text.shadow_offset_y)); + break; + case RR_TEXTURE_RGBA: + h += MAX(h, a->texture[i].data.rgba.height); + break; + case RR_TEXTURE_IMAGE: + /* images resize so they don't contribute anything to the min */ + break; + case RR_TEXTURE_LINE_ART: + h = MAX(h, MAX(a->texture[i].data.lineart.y1 - t - b, + a->texture[i].data.lineart.y2 - t - b)); break; } - } else if (l->surface.border) { - *w += 2; - *h += 2; } - if (*w < 1) *w = 1; - if (*h < 1) *h = 1; + h += t + b; + + if (h < 1) h = 1; + return h; } -gboolean render_pixmap_to_rgba(Pixmap pmap, Pixmap mask, - int *w, int *h, pixel32 **data) +static void reverse_bits(gchar *c, gint n) +{ + gint i; + for (i = 0; i < n; i++, c++) + *c = (((*c * 0x0802UL & 0x22110UL) | + (*c * 0x8020UL & 0x88440UL)) * 0x10101UL) >> 16; +} + +gboolean RrPixmapToRGBA(const RrInstance *inst, + Pixmap pmap, Pixmap mask, + gint *w, gint *h, RrPixel32 **data) { Window xr; - int xx, xy; + gint xx, xy; guint pw, ph, mw, mh, xb, xd, i, x, y, di; XImage *xi, *xm = NULL; - if (!XGetGeometry(ob_display, pmap, &xr, &xx, &xy, &pw, &ph, &xb, &xd)) + if (!XGetGeometry(RrDisplay(inst), pmap, + &xr, &xx, &xy, &pw, &ph, &xb, &xd)) return FALSE; + if (mask) { - if (!XGetGeometry(ob_display, mask, &xr, &xx, &xy, &mw, &mh, &xb, &xd)) + if (!XGetGeometry(RrDisplay(inst), mask, + &xr, &xx, &xy, &mw, &mh, &xb, &xd)) return FALSE; if (pw != mw || ph != mh || xd != 1) return FALSE; } - xi = XGetImage(ob_display, pmap, 0, 0, pw, ph, 0xffffffff, ZPixmap); + xi = XGetImage(RrDisplay(inst), pmap, + 0, 0, pw, ph, 0xffffffff, ZPixmap); if (!xi) return FALSE; if (mask) { - xm = XGetImage(ob_display, mask, 0, 0, mw, mh, 0xffffffff, ZPixmap); - if (!xm) + xm = XGetImage(RrDisplay(inst), mask, + 0, 0, mw, mh, 0xffffffff, ZPixmap); + if (!xm) { + XDestroyImage(xi); return FALSE; + } + if ((xm->bits_per_pixel == 1) && (xm->bitmap_bit_order != LSBFirst)) + reverse_bits(xm->data, xm->bytes_per_line * xm->height); } - *data = g_new(pixel32, pw * ph); - increase_depth(*data, xi); + if ((xi->bits_per_pixel == 1) && (xi->bitmap_bit_order != LSBFirst)) + reverse_bits(xi->data, xi->bytes_per_line * xi->height); + + *data = g_new(RrPixel32, pw * ph); + RrIncreaseDepth(inst, *data, xi); if (mask) { /* apply transparency from the mask */ @@ -481,7 +544,7 @@ gboolean render_pixmap_to_rgba(Pixmap pmap, Pixmap mask, for (i = 0, y = 0; y < ph; ++y) { for (x = 0; x < pw; ++x, ++i) { if (!((((unsigned)xm->data[di + x / 8]) >> (x % 8)) & 0x1)) - (*data)[i] &= ~(0xff << default_alpha_offset); + (*data)[i] &= ~(0xff << RrDefaultAlphaOffset); } di += xm->bytes_per_line; } @@ -490,5 +553,9 @@ gboolean render_pixmap_to_rgba(Pixmap pmap, Pixmap mask, *w = pw; *h = ph; + XDestroyImage(xi); + if (mask) + XDestroyImage(xm); + return TRUE; }