static void cdfbox(cdCtxCanvas *ctxcanvas, double xmin, double xmax, double ymin, double ymax)
{
if(ctxcanvas->canvas->back_opacity == CD_OPAQUE && glIsEnabled(GL_POLYGON_STIPPLE))
{
/* draw twice, one with background color only, and one with foreground color */
glDisable(GL_POLYGON_STIPPLE);
glColor4ub(cdRed(ctxcanvas->canvas->background),
cdGreen(ctxcanvas->canvas->background),
cdBlue(ctxcanvas->canvas->background),
cdAlpha(ctxcanvas->canvas->background));
glBegin(GL_QUADS);
glVertex2d(xmin, ymin);
glVertex2d(xmax, ymin);
glVertex2d(xmax, ymax);
glVertex2d(xmin, ymax);
glEnd();
/* restore the foreground color */
glColor4ub(cdRed(ctxcanvas->canvas->foreground),
cdGreen(ctxcanvas->canvas->foreground),
cdBlue(ctxcanvas->canvas->foreground),
cdAlpha(ctxcanvas->canvas->foreground));
glEnable(GL_POLYGON_STIPPLE);
}
glBegin(GL_QUADS);
glVertex2d(xmin, ymin);
glVertex2d(xmax, ymin);
glVertex2d(xmax, ymax);
glVertex2d(xmin, ymax);
glEnd();
(void)ctxcanvas;
}
static int iColorBrowserDlgColorCnvButton_CB(Ihandle* ih, int b, int press, int x, int y)
{
IcolorDlgData* colordlg_data = (IcolorDlgData*)iupAttribGetInherit(ih, "_IUP_GC_DATA");
int width;
(void)y;
if (b != IUP_BUTTON1 || !press || !colordlg_data->cd_canvas_color)
return IUP_DEFAULT;
cdCanvasGetSize(colordlg_data->cd_canvas_color, &width, NULL, NULL, NULL);
if (x < width/2)
{
/* reset color to previous */
colordlg_data->red = cdRed(colordlg_data->previous_color);
colordlg_data->green = cdGreen(colordlg_data->previous_color);
colordlg_data->blue = cdBlue(colordlg_data->previous_color);
colordlg_data->alpha = cdAlpha(colordlg_data->previous_color);
IupSetInt(colordlg_data->alpha_txt, "VALUE", (int)colordlg_data->alpha);
IupSetInt(colordlg_data->alpha_val, "VALUE", (int)colordlg_data->alpha);
iColorBrowserDlgRGB_TXT_Update(colordlg_data);
iColorBrowserDlgRGBChanged(colordlg_data);
}
return IUP_DEFAULT;
}
static void cdclear(cdCtxCanvas* ctxcanvas)
{
GLclampf r = (GLclampf)cdRed(ctxcanvas->canvas->background)/255.0f;
GLclampf g = (GLclampf)cdGreen(ctxcanvas->canvas->background)/255.0f;
GLclampf b = (GLclampf)cdBlue(ctxcanvas->canvas->background)/255.0f;
GLclampf a = (GLclampf)cdAlpha(ctxcanvas->canvas->background)/255.0f;
glClearColor(r, g, b, a);
glClear(GL_COLOR_BUFFER_BIT);
/* restore the foreground color */
glColor4ub(cdRed(ctxcanvas->canvas->foreground),
cdGreen(ctxcanvas->canvas->foreground),
cdBlue(ctxcanvas->canvas->foreground),
cdAlpha(ctxcanvas->canvas->foreground));
}
static long int cdforeground(cdCtxCanvas *ctxcanvas, long int color)
{
(void)ctxcanvas;
glColor4ub(cdRed(color),
cdGreen(color),
cdBlue(color),
cdAlpha(color));
return color;
}
static void cdpixel(cdCtxCanvas *ctxcanvas, int x, int y, long int color)
{
glColor4ub(cdRed(color),
cdGreen(color),
cdBlue(color),
cdAlpha(color));
/* Draw pixel */
glPointSize(1);
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
/* restore the foreground color */
glColor4ub(cdRed(ctxcanvas->canvas->foreground),
cdGreen(ctxcanvas->canvas->foreground),
cdBlue(ctxcanvas->canvas->foreground),
cdAlpha(ctxcanvas->canvas->foreground));
(void)ctxcanvas;
}
void simFillDrawAAPixel(cdCanvas *canvas, int x, int y, unsigned short alpha_weight)
{
unsigned char aa_alpha;
long color, aa_color;
switch(canvas->interior_style)
{
default: /* CD_SOLID */
{
color = canvas->foreground;
break;
}
case CD_PATTERN:
{
long *pattern = canvas->pattern;
int yp = CalcYPat(y, canvas->pattern_h);
int xp = x % canvas->pattern_w;
color = pattern[canvas->pattern_w*yp + xp];
break;
}
case CD_HATCH:
{
unsigned char hatch = SimHatchBits[canvas->hatch_style][CalcYHatch(y, 7)];
unsigned char n = (unsigned char)(x&7);
simRotateHatchN(hatch, n);
if (hatch & 0x80)
color = canvas->foreground;
else if (canvas->back_opacity == CD_OPAQUE)
color = canvas->background;
else
return;
break;
}
case CD_STIPPLE:
{
unsigned char *stipple = canvas->stipple;
int yp = CalcYPat(y, canvas->stipple_h);
int xp = x % canvas->stipple_w;
if(stipple[canvas->stipple_w*yp + xp])
color = canvas->foreground;
else if (canvas->back_opacity == CD_OPAQUE)
color = canvas->background;
else
return;
break;
}
}
aa_alpha = (unsigned char)((alpha_weight * cdAlpha(color)) / 255);
aa_color = cdEncodeAlpha(color, aa_alpha);
canvas->cxPixel(canvas->ctxcanvas, x, y, aa_color);
}
static void cdfpoly(cdCtxCanvas *ctxcanvas, int mode, cdfPoint* poly, int n)
{
int i;
if (mode == CD_CLIP)
return;
if (mode == CD_BEZIER)
{
int i, prec = 100;
double (*points)[3] = malloc(n * sizeof(*points));
for(i = 0; i < n; i++)
{
points[i][0] = poly[i].x;
points[i][1] = poly[i].y;
points[i][2] = 0;
}
glMap1d(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, n, &points[0][0]);
glEnable(GL_MAP1_VERTEX_3);
glMapGrid1d(prec, 0.0, 1.0);
glEvalMesh1(GL_LINE, 0, prec);
glDisable(GL_MAP1_VERTEX_3);
free(points);
return;
}
if (mode == CD_PATH)
{
cdfSimPolyPath(ctxcanvas->canvas, poly, n);
return;
}
switch (mode)
{
case CD_CLOSED_LINES :
glBegin(GL_LINE_LOOP);
break;
case CD_OPEN_LINES :
glBegin(GL_LINE_STRIP);
break;
case CD_FILL :
if(ctxcanvas->canvas->back_opacity == CD_OPAQUE && glIsEnabled(GL_POLYGON_STIPPLE))
{
glDisable(GL_POLYGON_STIPPLE);
glColor4ub(cdRed(ctxcanvas->canvas->background),
cdGreen(ctxcanvas->canvas->background),
cdBlue(ctxcanvas->canvas->background),
cdAlpha(ctxcanvas->canvas->background));
glBegin(GL_POLYGON);
for(i = 0; i < n; i++)
glVertex2d(poly[i].x, poly[i].y);
glEnd();
/* restore the foreground color */
glColor4ub(cdRed(ctxcanvas->canvas->foreground),
cdGreen(ctxcanvas->canvas->foreground),
cdBlue(ctxcanvas->canvas->foreground),
cdAlpha(ctxcanvas->canvas->foreground));
glEnable(GL_POLYGON_STIPPLE);
}
glBegin(GL_POLYGON);
break;
}
for(i = 0; i < n; i++)
glVertex2d(poly[i].x, poly[i].y);
glEnd();
(void)ctxcanvas;
}
static void simDrawTextBitmap(cdSimulation* simulation, FT_Bitmap* bitmap, int x, int y)
{
unsigned char *red, *green, *blue, *alpha, *bitmap_data;
int width = bitmap->width;
int height = bitmap->rows;
int size = width*height;
int rgba_data_size = size*4;
int old_use_matrix = simulation->canvas->use_matrix;
/* avoid spaces */
if (width == 0 || height == 0)
return;
if (!simulation->tt_text->rgba_data)
simulation->tt_text->rgba_data = malloc(rgba_data_size);
else if (rgba_data_size > simulation->tt_text->rgba_data_size)
{
simulation->tt_text->rgba_data = realloc(simulation->tt_text->rgba_data, rgba_data_size);
simulation->tt_text->rgba_data_size = rgba_data_size;
}
/* disable image transformation */
simulation->canvas->use_matrix = 0;
/* this is the char bitmap, contains an alpha map of the char
to be combined with the foreground color */
bitmap_data = bitmap->buffer + (height-1)*width; /* bitmap is top down. */
/* this is the image used to draw the char with the foreground color */
red = simulation->tt_text->rgba_data;
green = red + size;
blue = green + size;
alpha = blue + size;
if (!simulation->canvas->cxPutImageRectRGBA && !simulation->canvas->cxGetImageRGB)
{
int i, j;
unsigned char bg_red, bg_green, bg_blue,
fg_red, fg_green, fg_blue, fg_alpha, calpha;
long int c;
/* must manually combine using only the background color, ignore canvas contents */
c = simulation->canvas->background;
bg_red = cdRed(c);
bg_green = cdGreen(c);
bg_blue = cdBlue(c);
c = simulation->canvas->foreground;
fg_red = cdRed(c);
fg_green = cdGreen(c);
fg_blue = cdBlue(c);
fg_alpha = cdAlpha(c);
for (i = 0; i < height; i++)
{
for (j = 0; j < width; j++)
{
if (simulation->antialias)
{
if (fg_alpha == 255)
calpha = bitmap_data[j];
else
calpha = (fg_alpha*bitmap_data[j])/255;
}
else
{
if (bitmap_data[j] > 128) /* behave as 255 */
calpha = fg_alpha;
else
calpha = 0;
}
*red++ = CD_ALPHA_BLEND(fg_red, bg_red, calpha);
*green++ = CD_ALPHA_BLEND(fg_green, bg_green, calpha);
*blue++ = CD_ALPHA_BLEND(fg_blue, bg_blue, calpha);
}
bitmap_data -= width;
}
/* reset pointers */
red = simulation->tt_text->rgba_data;
green = red + size;
blue = green + size;
/* draw the char */
simulation->canvas->cxPutImageRectRGB(simulation->canvas->ctxcanvas, width,height,red,green,blue,x,y,width,height,0,width-1,0,height-1);
}
else
{
int i, j;
long int fg = simulation->canvas->foreground;
unsigned char fg_alpha = cdAlpha(fg);
memset(red, cdRed(fg), size);
memset(green, cdGreen(fg), size);
memset(blue, cdBlue(fg), size);
/* alpha is the bitmap_data itself
if the foreground color does not contains alpha.
Also must invert since it is top-down. */
for (i = 0; i < height; i++)
{
if (simulation->antialias)
{
if (fg_alpha == 255)
{
memcpy(alpha, bitmap_data, width);
alpha += width;
}
else
{
for (j = 0; j < width; j++)
{
*alpha++ = (fg_alpha*bitmap_data[j])/255;
}
}
}
else
{
for (j = 0; j < width; j++)
{
if (bitmap_data[j] > 128) /* behave as 255 */
*alpha++ = fg_alpha;
else
*alpha++ = 0;
}
}
bitmap_data -= width;
}
/* reset alpha pointer */
alpha = blue + size;
/* draw the char */
simulation->canvas->cxPutImageRectRGBA(simulation->canvas->ctxcanvas, width,height,red,green,blue,alpha,x,y,width,height,0,width-1,0,height-1);
}
simulation->canvas->use_matrix = old_use_matrix;
}
