diff options
author | Bernie Innocenti <bernie@codewiz.org> | 2010-05-03 21:53:47 (GMT) |
---|---|---|
committer | Bernie Innocenti <bernie@codewiz.org> | 2010-05-03 21:53:47 (GMT) |
commit | 1030dc837b10a03a02a85d5504cbeec168ce49e2 (patch) | |
tree | 698eefa87ac437deaf36a4141b326f8ce7986692 /src/filter/grlib.c |
Import XaoS r489 (trunk after version 3.5)
Diffstat (limited to 'src/filter/grlib.c')
-rw-r--r-- | src/filter/grlib.c | 995 |
1 files changed, 995 insertions, 0 deletions
diff --git a/src/filter/grlib.c b/src/filter/grlib.c new file mode 100644 index 0000000..74692d4 --- /dev/null +++ b/src/filter/grlib.c @@ -0,0 +1,995 @@ +#include <config.h> +#ifdef _plan9_ +#include <u.h> +#include <libc.h> +#else +#include <stdlib.h> +#include <string.h> +#endif +#ifdef HAVE_GETTEXT +#include <iconv.h> +#endif +#include <archaccel.h> + +#include <fconfig.h> +#include <filter.h> +#include <fractal.h> +#include <ui_helper.h> +#include <grlib.h> + +#define WIDTH(ch) (currentfont->width) +#define RWIDTH(ch) (currentfont->realwidth) +#define HEIGHT (currentfont->height) +#define DATA currentfont->data + +extern CONST unsigned char xfont8[]; +extern CONST unsigned char xfont16[]; +extern CONST unsigned char xfont32[]; +extern CONST unsigned char xfont48[]; +extern CONST unsigned char xfont14[]; +extern CONST unsigned char xfont8il1[]; +extern CONST unsigned char xfont16il1[]; +extern CONST unsigned char xfont14il1[]; +unsigned char *aa_chardata; +unsigned char *aa_colordata; +int aa_cursorx, aa_cursory; +static CONST struct xfont *currentfont; +CONST struct xfont xaafont = { + NULL, + 2, 1, 2, 2 +}; + +CONST struct xfont xsmallfont = { + xfont14, + 8, 14, 8, 2 +}; + +CONST struct xfont xbigfont = { + xfont16, + 9, 16, 8, 2 +}; + +CONST struct xfont xbigfont2 = { + xfont32, + 18, 32, 16, 2 +}; + +CONST struct xfont xbigfont3 = { + xfont48, + 18, 48, 16, 2 +}; + +CONST struct xfont xsmallfontil1 = { + xfont8il1, + 8, 8, 8, 1 +}; + +CONST struct xfont xmedfontil1 = { + xfont14il1, + 8, 14, 8, 1 +}; + +CONST struct xfont xbigfontil1 = { + xfont16il1, + 9, 16, 8, 1 +}; + +#include <c256.h> +#define drawchar drawchar8 +#define hline hline8 +#define vline vline8 +#define rectangle rectangle8 +#define savevline savevline8 +#define restorevline restorevline8 +#define line line8 +#define saveline saveline8 +#define restoreline restoreline8 +#include "grlibd.c" +#include <hicolor.h> +#define drawchar drawchar16 +#define hline hline16 +#define vline vline16 +#define rectangle rectangle16 +#define savevline savevline16 +#define restorevline restorevline16 +#define line line16 +#define saveline saveline16 +#define restoreline restoreline16 +#include "grlibd.c" +#include <true24.h> +#define drawchar drawchar24 +#define hline hline24 +#define vline vline24 +#define rectangle rectangle24 +#define savevline savevline24 +#define restorevline restorevline24 +#define line line24 +#define saveline saveline24 +#define restoreline restoreline24 +#include "grlibd.c" +#include <truecolor.h> +#define drawchar drawchar32 +#define hline hline32 +#define vline vline32 +#define rectangle rectangle32 +#define savevline savevline32 +#define restorevline restorevline32 +#define line line32 +#define saveline saveline32 +#define restoreline restoreline32 +#include "grlibd.c" +#ifdef SBITMAPS +static inline void +drawchar1(struct image *img, int x, int y, int fgcolor, + unsigned char letter) +{ + int fontwidth = (RWIDTH(letter) + 7) / 8; + CONST unsigned char *bitmap = &DATA[letter * HEIGHT * fontwidth]; + unsigned char *current; + int yend = y + HEIGHT; + if (y < 0) + bitmap -= y, y = 0; + if (yend > img->height) + yend = img->height; + for (; y < yend; y++) { + unsigned int b = *(bitmap++); + if (fontwidth == 2) { + b <<= 8; + b |= *bitmap++; + } + current = img->currlines[y] + x / 8; + b = b << (8 - ((x) & 7)); +#ifdef SLBITMAPS + if (img->palette->type & (LBITMAP | LIBITMAP)) { + /*Reverse order... */ + b = ((b >> 1) & 0x5555) | ((b << 1) & 0xaaaa); + b = ((b >> 2) & 0x3333) | ((b << 2) & 0xcccc); + b = ((b >> 4) & 0x0f0f) | ((b << 4) & 0xf0f0); + } +#endif + if (fgcolor) { + if (x & 7) { + current[1] |= b; + current[0] |= b >> 8; + } else + current[0] |= b >> 8; + } else { + if (x & 7) { + current[1] &= ~b; + current[0] &= ~(b >> 8); + } else + *current &= ~(b >> 8); + } + } +} + +static void hline1(struct image *img, int x, int y, int l, int color) +{ + int x2 = x + l; + int c1 = 255; + int c2 = 255; + unsigned char *current = img->currlines[y] + x / 8; + unsigned char *currend = img->currlines[y] + x2 / 8; + if (img->palette->type & (LBITMAP | LIBITMAP)) { + c2 >>= x2 & 7; + c1 <<= 8 - (x & 7); + } else { + c1 >>= x & 7; + c2 <<= 8 - (x2 & 7); + } + if (current == currend) { + if (color) + *current |= c1 & c2; + else + *current &= ~(c1 & c2); + } else { + if (color) { + *current |= c1; + *currend |= c2; + memset(current + 1, (char) 255, currend - current - 1); + } else { + *current &= ~c1; + *currend &= ~c2; + memset(current + 1, 0, currend - current - 1); + } + } +} + +static void vline1(struct image *img, int x, int y, int l, int color) +{ + unsigned char c = 128 >> (x & 7); + l += y; + x /= 8; + if (img->palette->type & (LBITMAP | LIBITMAP)) { + c = ((c >> 1) & 0x55) | ((c << 1) & 0xaa); + c = ((c >> 2) & 0x33) | ((c << 2) & 0xcc); + c = ((c >> 4) & 0x0f) | ((c << 4) & 0xf0); + } + if (color) + while (y <= l) { + unsigned char *current = img->currlines[y] + x; + *current |= c; + y++; + } else { + c = ~c; + while (y <= l) { + unsigned char *current = img->currlines[y] + x; + *current &= c; + y++; + } + } +} + +static inline void +rectangle1(struct image *img, int x, int y, int width, int height, + int fgcolor) +{ + height += y; + while (y < height) + hline1(img, x, y, width - 1, fgcolor), y++; +} + +static inline void +line1(struct image *img, int x, int y, int x2, int y2, int color) +{ + int dx = x2 - x; + int dy = y2 - y; + int ady = abs(dy); +#ifdef SLBITMAPS + int type = img->palette->type; +#endif + if (dx < ady) { + int plus = (dx << 16) / ady; + if (dy < 0) { + int dy = (x << 16) | (65536 / 2); + ady = y; +#ifdef SLBITMAPS + if (type & (LBITMAP | LIBITMAP)) + if (!color) + while (ady >= y2) { + unsigned char *current = + img->currlines[ady] + (dy >> 19); + *current &= ~(1 << ((dy >> 16) & 7)); + dy += plus; + ady--; + } else + while (ady >= y2) { + unsigned char *current = + img->currlines[ady] + (dy >> 19); + *current |= (1 << ((dy >> 16) & 7)); + dy += plus; + ady--; + } else +#endif + if (!color) + while (ady >= y2) { + unsigned char *current = + img->currlines[ady] + (dy >> 19); + *current &= ~(128 >> ((dy >> 16) & 7)); + dy += plus; + ady--; + } else + while (ady >= y2) { + unsigned char *current = + img->currlines[ady] + (dy >> 19); + *current |= (128 >> ((dy >> 16) & 7)); + dy += plus; + ady--; + } + } else { + int dy = (x << 16) | (65536 / 2); + ady = y; +#ifdef SLBITMAPS + if (type & (LBITMAP | LIBITMAP)) + if (!color) + while (ady <= y2) { + unsigned char *current = + img->currlines[ady] + (dy >> 19); + *current &= ~(1 << ((dy >> 16) & 7)); + dy += plus; + ady++; + } else + while (ady <= y2) { + unsigned char *current = + img->currlines[ady] + (dy >> 19); + *current |= (1 << ((dy >> 16) & 7)); + dy += plus; + ady++; + } else +#endif + if (!color) + while (ady <= y2) { + unsigned char *current = + img->currlines[ady] + (dy >> 19); + *current &= ~(128 >> ((dy >> 16) & 7)); + dy += plus; + ady++; + } else + while (ady <= y2) { + unsigned char *current = + img->currlines[ady] + (dy >> 19); + *current |= (128 >> ((dy >> 16) & 7)); + dy += plus; + ady++; + } + } + } else { + int plus = (dy << 16) / dx; + ady = x; + dy = (y << 16) | (65536 / 2); +#ifdef SLBITMAPS + if (type & (LBITMAP | LIBITMAP)) + if (!color) + while (ady <= x2) { + unsigned char *current = + img->currlines[dy >> 16] + (ady >> 3); + *current &= ~(1 << (ady & 7)); + dy += plus; + ady++; + } else + while (ady <= x2) { + unsigned char *current = + img->currlines[dy >> 16] + (ady >> 3); + *current |= (1 << (ady & 7)); + dy += plus; + ady++; + } else +#endif + if (!color) + while (ady <= x2) { + unsigned char *current = + img->currlines[dy >> 16] + (ady >> 3); + *current &= ~(128 >> (ady & 7)); + dy += plus; + ady++; + } else + while (ady <= x2) { + unsigned char *current = + img->currlines[dy >> 16] + (ady >> 3); + *current |= (128 >> (ady & 7)); + dy += plus; + ady++; + } + } + return; +} +#endif + +static int skip(CONST char *text) +{ + int i = 0; + while (*text && *text != '\n') + i++, text++; + return (i); +} + +#ifdef HAVE_GETTEXT +int +xiconv(int encoding, char *out, int *outlen, const char *in, int *inlen) +{ + /* + * Since the built-in text system only supports Latin-1 and Lqtin-2 + * encodings, we must convert strings from the user's native encoding to + * either Latin-1 or Latin-2 encoding as appropriate for the selected + * language before passing them into the built-in text system. This + * function wraps the gnu iconv library for this purpose. + */ + + iconv_t cd; + char tocode[16]; + size_t icv_inlen = *inlen, icv_outlen = *outlen; + const char *icv_in = (const char *) in; + char *icv_out = (char *) out; + int ret; + + sprintf(tocode, "ISO-8859-%d", encoding); + cd = iconv_open(tocode, "UTF-8"); + if (cd == (iconv_t) (-1)) + return -1; + + ret = iconv(cd, &icv_in, &icv_inlen, &icv_out, &icv_outlen); + + if (in != NULL) { + *inlen -= icv_inlen; + *outlen -= icv_outlen; + out[*outlen] = '\0'; + } else { + *inlen = 0; + *outlen = 0; + } + + if (icv_inlen != 0 || ret == (size_t) - 1) + return -1; + + ret = iconv_close(cd); + + if (ret == -1) + return -1; + + return 0; +} +#endif + +#ifndef PLATFORM_TEXT_RENDERING + +int +xprint(struct image *image, CONST struct xfont *current, int x, int y, + CONST char *text, int fgcolor, int bgcolor, int mode) +{ + int i = 0; + int aacolor = 0; + char intext[BUFSIZ]; + int inlen = strlen(text); + char outtext[BUFSIZ]; + int outlen = BUFSIZ; + strncpy(intext, text, BUFSIZ); + +#ifdef HAVE_GETTEXT + if (current->encoding + && xiconv(current->encoding, outtext, &outlen, intext, &inlen) == 0) + text = outtext; +#endif + if (!text[0]) + return 0; + /*Do some clipping */ + currentfont = current; + if (x + WIDTH(*text) > image->width) + return skip(text); + if (y + HEIGHT <= 0) + return skip(text); + if (y >= image->height) + return skip(text); + while (x < 0 && *text && *text != '\n') + text++, x += WIDTH(*text), i++; + if (x < 0) + return (skip(text) + i); + + if (image->flags & AAIMAGE) { + aacolor = 0; /*normal */ + if ((unsigned int) fgcolor == image->palette->index[2]) + aacolor = 2; + if ((unsigned int) fgcolor == image->palette->index[0]) + aacolor = 5; /*special */ + } + /*Draw text visible letters */ + while (x + WIDTH(*text) < image->width && *text && *text != '\n') { + if (image->flags & AAIMAGE) { + aa_colordata[x / 2 + y / 2 * (image->width / 2)] = aacolor; + aa_chardata[x / 2 + y / 2 * (image->width / 2)] = *text; + } else + switch (image->bytesperpixel) { +#ifdef SBITMAPS + case 0: + if (mode == TEXT_PRESSED) { + drawchar1(image, x + 1, y + 1, fgcolor, *text); + } else { + drawchar1(image, x + 1, y + 1, bgcolor, *text); + drawchar1(image, x, y, fgcolor, *text); + } + break; +#endif + case 1: + if (mode == TEXT_PRESSED) { + drawchar8(image, x + 1, y + 1, fgcolor, *text); + } else { + drawchar8(image, x + 1, y + 1, bgcolor, *text); + drawchar8(image, x, y, fgcolor, *text); + } + break; +#ifdef SUPPORT16 + case 2: + if (mode == TEXT_PRESSED) { + drawchar16(image, x + 1, y + 1, fgcolor, *text); + } else { + drawchar16(image, x + 1, y + 1, bgcolor, *text); + drawchar16(image, x, y, fgcolor, *text); + } + break; +#endif +#ifdef STRUECOLOR24 + case 3: + if (mode == TEXT_PRESSED) { + drawchar24(image, x + 1, y + 1, fgcolor, *text); + } else { + drawchar24(image, x + 1, y + 1, bgcolor, *text); + drawchar24(image, x, y, fgcolor, *text); + } + break; +#endif + case 4: + if (mode == TEXT_PRESSED) { + drawchar32(image, x + 1, y + 1, fgcolor, *text); + } else { + drawchar32(image, x + 1, y + 1, bgcolor, *text); + drawchar32(image, x, y, fgcolor, *text); + } + break; + } + x += WIDTH(*text); + text++; + i++; + } + /* + * We need to return the number of bytes used from the string that is + * passed into the function; not the number of characters displayed. The + * number of bytes and the number of characters is not always the same in + * UTF-8 encoding. So I changed this to count the number of bytes to + * the next newline or nul in the original string that was passed in. + */ + /* return i + skip(text); */ + return skip(intext); +} + +int xtextwidth(CONST struct xfont *font, CONST char *text) +{ + int i; +#ifdef HAVE_GETTEXT + char intext[BUFSIZ]; + int inlen = strlen(text); + char outtext[BUFSIZ]; + int outlen = BUFSIZ; + + strncpy(intext, text, BUFSIZ); + if (font->encoding + && xiconv(font->encoding, outtext, &outlen, intext, &inlen) == 0) + text = outtext; +#endif + for (i = 0; text[i] && text[i] != '\n'; i++); + if (font->width == 2) + return (i * font->width); + return (i * font->width + 1); +} + +int xtextheight(CONST struct xfont *font) +{ + return font->height+1; +} + +int xtextcharw(CONST struct xfont *font, CONST char c) +{ + return font->width; +} + +#endif + +void xhline(struct image *image, int x, int y, int width, int fgcolor) +{ + /*Do some clipping */ + if (x + width < 0 || y < 0 || y >= image->height || x >= image->width) + return; + if (x + width >= image->width - 1) + width = image->width - x - 2; + if (x < 0) + width += x, x = 0; + if (width < 0) + return; + switch (image->bytesperpixel) { +#ifdef SBITMAPS + case 0: + hline1(image, x, y, width, fgcolor); + break; +#endif + case 1: + hline8(image, x, y, width, fgcolor); + break; +#ifdef SUPPORT16 + case 2: + hline16(image, x, y, width, fgcolor); + break; +#endif +#ifdef STRUECOLOR24 + case 3: + hline24(image, x, y, width, fgcolor); + break; +#endif + case 4: + hline32(image, x, y, width, fgcolor); + break; + } +} + +void xvline(struct image *image, int x, int y, int height, int fgcolor) +{ + /*Do some clipping */ + if (x < 0 || y + height < 0 || y >= image->height || x >= image->width) + return; + if (y + height >= image->height - 1) + height = image->height - y - 2; + if (y < 0) + height += y, y = 0; + if (height < 0) + return; + switch (image->bytesperpixel) { +#ifdef SBITMAPS + case 0: + vline1(image, x, y, height, fgcolor); + break; +#endif + case 1: + vline8(image, x, y, height, fgcolor); + break; +#ifdef SUPPORT16 + case 2: + vline16(image, x, y, height, fgcolor); + break; +#endif +#ifdef STRUECOLOR24 + case 3: + vline24(image, x, y, height, fgcolor); + break; +#endif + case 4: + vline32(image, x, y, height, fgcolor); + break; + } +} + +void +xrectangle(struct image *image, int x, int y, int width, int height, + int fgcolor) +{ + /*Do some clipping */ + if (x + width < 0 || y + height < 0 || y >= image->height + || x >= image->width) + return; + if (x + width >= image->width) + width = image->width - x; + if (x < 0) + width += x, x = 0; + if (width < 0) + return; + if (y + height >= image->height) + height = image->height - y; + if (y < 0) + height += y, y = 0; + if (height < 0) + return; + if (image->flags & AAIMAGE) { + int x1, y1; + for (x1 = x / 2; x1 < (x + width) / 2; x1++) + for (y1 = y / 2; y1 < (y + height) / 2; y1++) + aa_colordata[x1 + y1 * image->width / 2] = 255; + } + switch (image->bytesperpixel) { +#ifdef SBITMAPS + case 0: + rectangle1(image, x, y, width, height, fgcolor); + break; +#endif + case 1: + rectangle8(image, x, y, width, height, fgcolor); + break; +#ifdef SUPPORT16 + case 2: + rectangle16(image, x, y, width, height, fgcolor); + break; +#endif +#ifdef STRUECOLOR24 + case 3: + rectangle24(image, x, y, width, height, fgcolor); + break; +#endif + case 4: + rectangle32(image, x, y, width, height, fgcolor); + break; + } +} + +static inline char *savehline(struct image *i, int x1, int y, int x2) +{ + int start, end; + char *c; + if (!i->bytesperpixel) + start = (x1) / 8, end = (x2 + 1 + 7) / 8; + else + start = x1 * i->bytesperpixel, end = (x2 + 1) * i->bytesperpixel; + c = (char *) malloc(end - start); + if (c == NULL) + return NULL; + memcpy(c, i->currlines[y] + start, end - start); + return c; +} + +static inline void +restorehline(struct image *i, char *c, int x1, int y, int x2) +{ + int start, end; + if (!i->bytesperpixel) + start = (x1) / 8, end = (x2 + 1 + 7) / 8; + else + start = x1 * i->bytesperpixel, end = (x2 + 1) * i->bytesperpixel; + memcpy(i->currlines[y] + start, c, end - start); +} + +#define __clipx1 0 +#define __clipy1 0 +#define __clipx2 (img->width-2) +#define __clipy2 (img->height-2) +static inline int regioncode(struct image *img, const int x, const int y) +{ + int dx1, dx2, dy1, dy2; + int result; + result = 0; + dy2 = __clipy2 - y; + if (dy2 < 0) + result++; + result <<= 1; + dy1 = y - __clipy1; + if (dy1 < 0) + result++; + result <<= 1; + dx2 = __clipx2 - x; + if (dx2 < 0) + result++; + result <<= 1; + dx1 = x - __clipx1; + if (dx1 < 0) + result++; + return result; +} + +#define swap(x, y) { int temp = x; x = y; y = temp; } +#define doclip(ret) \ + for (;;) \ + { \ + int r1 = regioncode (img, x1, y1); \ + int r2 = regioncode (img, x2, y2); \ + if (!(r1 | r2)) \ + break; /* completely inside */ \ + if (r1 & r2) \ + ret; /* completely outside */ \ + if (r1 == 0) \ + { \ + swap (x1, x2); /* make sure first */ \ + swap (y1, y2); /* point is outside */ \ + r1 = r2; \ + } \ + if (r1 & 1) \ + { /* left */ \ + y1 += (long) (__clipx1 - x1) * (long) (y2 - y1) / (long) (x2 - x1); \ + x1 = __clipx1; \ + } \ + else if (r1 & 2) \ + { /* right */ \ + y1 += (long) (__clipx2 - x1) * (long) (y2 - y1) / (long) (x2 - x1); \ + x1 = __clipx2; \ + } \ + else if (r1 & 4) \ + { /* top */ \ + x1 += (long) (__clipy1 - y1) * (long) (x2 - x1) / (long) (y2 - y1); \ + y1 = __clipy1; \ + } \ + else if (r1 & 8) \ + { /* bottom */ \ + x1 += (long) (__clipy2 - y1) * (long) (x2 - x1) / (long) (y2 - y1); \ + y1 = __clipy2; \ + } \ + } \ + if(x2<x1) { \ + swap(x1,x2); \ + swap(y1,y2); \ + } + +void xline(struct image *img, int x1, int y1, int x2, int y2, int color) +{ + doclip(return); + if (x1 == x2) { + if (y2 < y1) { + swap(y1, y2); + } + switch (img->bytesperpixel) { +#ifdef SBITMAPS + case 0: + vline1(img, x1, y1, y2 - y1, color); + break; +#endif + case 1: + vline8(img, x1, y1, y2 - y1, color); + break; +#ifdef SUPPORT16 + case 2: + vline16(img, x1, y1, y2 - y1, color); + break; +#endif +#ifdef STRUECOLOR24 + case 3: + vline24(img, x1, y1, y2 - y1, color); + break; +#endif + case 4: + vline32(img, x1, y1, y2 - y1, color); + break; + } + } else if (y1 == y2) { + switch (img->bytesperpixel) { +#ifdef SBITMAPS + case 0: + hline1(img, x1, y1, x2 - x1, color); + break; +#endif + case 1: + hline8(img, x1, y1, x2 - x1, color); + break; +#ifdef SUPPORT16 + case 2: + hline16(img, x1, y1, x2 - x1, color); + break; +#endif +#ifdef STRUECOLOR24 + case 3: + hline24(img, x1, y1, x2 - x1, color); + break; +#endif + case 4: + hline32(img, x1, y1, x2 - x1, color); + break; + } + } else { + switch (img->bytesperpixel) { +#ifdef SBITMAPS + case 0: + line1(img, x1, y1, x2, y2, color); + break; +#endif + case 1: + line8(img, x1, y1, x2, y2, color); + break; +#ifdef SUPPORT16 + case 2: + line16(img, x1, y1, x2, y2, color); + break; +#endif +#ifdef STRUECOLOR24 + case 3: + line24(img, x1, y1, x2, y2, color); + break; +#endif + case 4: + line32(img, x1, y1, x2, y2, color); + break; + } + } +} + +char *xsaveline(struct image *img, int x1, int y1, int x2, int y2) +{ + doclip(return (NULL)); + if (y1 == y2) { + return (savehline(img, x1, y1, x2)); + } else if (x1 == x2) { + if (y2 < y1) { + swap(y1, y2); + } + switch (img->bytesperpixel) { +#ifdef SBITMAPS + case 0: + return (savevline8(img, x1 / 8, y1, y2 - y1)); +#endif + case 1: + return (savevline8(img, x1, y1, y2 - y1)); +#ifdef SUPPORT16 + case 2: + return (savevline16(img, x1, y1, y2 - y1)); +#endif +#ifdef STRUECOLOR24 + case 3: + return (savevline24(img, x1, y1, y2 - y1)); +#endif + case 4: + return (savevline32(img, x1, y1, y2 - y1)); + } + } else { + switch (img->bytesperpixel) { +#ifdef SBITMAPS + case 0: + if (x2 > img->height - 15) + x2 = img->height - 15; + if (x1 > img->height - 15) + x1 = img->height - 15; + return (saveline8(img, (x1 / 8), y1, (x2 / 8), y2)); +#endif + case 1: + return (saveline8(img, x1, y1, x2, y2)); +#ifdef SUPPORT16 + case 2: + return (saveline16(img, x1, y1, x2, y2)); +#endif +#ifdef STRUECOLOR24 + case 3: + return (saveline24(img, x1, y1, x2, y2)); +#endif + case 4: + return (saveline32(img, x1, y1, x2, y2)); + } + } + return NULL; +} + +void xprepareimage(struct image *img) +{ + if (img->flags & AAIMAGE) { + memset(aa_colordata, (char) 255, img->width * img->height / 4); + } + aa_cursorx = -1; + aa_cursory = -1; +} + +void xdrawcursor(struct image *img, int x, int y, int color, int height) +{ + if (img->flags & AAIMAGE) { + aa_cursorx = x / 2; + aa_cursory = y / 2; + } else { + xvline(img, x, y, height, color); + xhline(img, x - 1, y - 1, 1, color); + xhline(img, x + 1, y - 1, 1, color); + xhline(img, x - 1, y + height, 1, color); + xhline(img, x + 1, y + height, 1, color); + } +} + +void +xrestoreline(struct image *img, char *data, int x1, int y1, int x2, int y2) +{ + doclip(return); + if (y1 == y2) { + restorehline(img, data, x1, y1, x2); + return; + } else if (x1 == x2) { + if (y2 < y1) { + swap(y1, y2); + } + switch (img->bytesperpixel) { +#ifdef SBITMAPS + case 0: + restorevline8(img, data, x1 / 8, y1, y2 - y1); + break; +#endif + case 1: + restorevline8(img, data, x1, y1, y2 - y1); + break; +#ifdef SUPPORT16 + case 2: + restorevline16(img, data, x1, y1, y2 - y1); + break; +#endif +#ifdef STRUECOLOR24 + case 3: + restorevline24(img, data, x1, y1, y2 - y1); + break; +#endif + case 4: + restorevline32(img, data, x1, y1, y2 - y1); + break; + } + } else { + switch (img->bytesperpixel) { +#ifdef SBITMAPS + case 0: + if (x2 > img->height - 15) + x2 = img->height - 15; + if (x1 > img->height - 15) + x1 = img->height - 15; + restoreline8(img, data, x1 / 8, y1, x2 / 8, y2); + break; +#endif + case 1: + restoreline8(img, data, x1, y1, x2, y2); + break; +#ifdef SUPPORT16 + case 2: + restoreline16(img, data, x1, y1, x2, y2); + break; +#endif +#ifdef STRUECOLOR24 + case 3: + restoreline24(img, data, x1, y1, x2, y2); + break; +#endif + case 4: + restoreline32(img, data, x1, y1, x2, y2); + break; + } + } + return; +} |