tk-zinc
view release on metacpan or search on metacpan
}
return TCL_OK;
}
static void
UpdateTristrip(CurveItem cv,
ZnPoly *poly,
ZnBool revert)
{
ZnCombineData *cdata, *cnext;
GLdouble v[3];
unsigned int j, k;
int i;
//printf("UpdateTristrips sur %d\n", ((ZnItem) cv)->id);
gluTessProperty(ZnTesselator.tess, GLU_TESS_WINDING_RULE, (GLdouble) cv->fill_rule);
if (cv->tristrip.num_strips == 0) {
gluTessProperty(ZnTesselator.tess, GLU_TESS_BOUNDARY_ONLY, (GLdouble) GL_FALSE);
gluTessBeginPolygon(ZnTesselator.tess, &cv->tristrip);
v[0] = poly->contours[j].points[i].x;
v[1] = poly->contours[j].points[i].y;
v[2] = 0;
gluTessVertex(ZnTesselator.tess, v, &poly->contours[j].points[i]);
}
//printf("\n");
gluTessEndContour(ZnTesselator.tess);
}
}
gluTessEndPolygon(ZnTesselator.tess);
cdata = ZnTesselator.combine_list;
//printf("Combine length: %d\n", ZnTesselator.combine_length);
while (cdata) {
ZnTesselator.combine_length--;
cnext = cdata->next;
ZnFree(cdata);
cdata = cnext;
}
ZnTesselator.combine_list = NULL;
}
//printf("Fin UpdateTristrips sur %d\n", ((ZnItem) cv)->id);
}
static void
UpdateOutlines(CurveItem cv,
ZnPoly *poly,
ZnBool revert)
{
ZnCombineData *cdata, *cnext;
GLdouble v[3];
unsigned int j, k;
int i;
//printf("UpdateOutlines sur %d\n", ((ZnItem) cv)->id);
gluTessProperty(ZnTesselator.tess, GLU_TESS_WINDING_RULE, (GLdouble) cv->fill_rule);
if (cv->outlines.num_contours == 0) {
gluTessProperty(ZnTesselator.tess, GLU_TESS_BOUNDARY_ONLY, (GLdouble) GL_TRUE);
gluTessBeginPolygon(ZnTesselator.tess, &cv->outlines);
for (i = (int) (poly->contours[j].num_points-1); i >= 0; i--) {
v[0] = poly->contours[j].points[i].x;
v[1] = poly->contours[j].points[i].y;
v[2] = 0;
gluTessVertex(ZnTesselator.tess, v, &poly->contours[j].points[i]);
}
gluTessEndContour(ZnTesselator.tess);
}
}
gluTessEndPolygon(ZnTesselator.tess);
cdata = ZnTesselator.combine_list;
while (cdata) {
ZnTesselator.combine_length--;
cnext = cdata->next;
ZnFree(cdata);
cdata = cnext;
}
ZnTesselator.combine_list = NULL;
}
//printf("Fin UpdateOutlines sur %d\n", ((ZnItem) cv)->id);
}
/*
**********************************************************************************
*
PostScript.c view on Meta::CPAN
#ifdef WIN32
#include <windows.h>
/*
* We could just define these instead of pulling in windows.h.
#define GetRValue(rgb) ((BYTE)(rgb))
#define GetGValue(rgb) ((BYTE)(((WORD)(rgb)) >> 8))
#define GetBValue(rgb) ((BYTE)((rgb)>>16))
*/
#else
#define GetRValue(rgb) ((rgb & cdata->red_mask) >> cdata->red_shift)
#define GetGValue(rgb) ((rgb & cdata->green_mask) >> cdata->green_shift)
#define GetBValue(rgb) ((rgb & cdata->blue_mask) >> cdata->blue_shift)
#endif
#if defined(WIN32) || defined(MAC_OSX_TK)
static void
TkImageGetColor(cdata, pixel, red, green, blue)
TkColormapData *cdata; /* Colormap data */
unsigned long pixel; /* Pixel value to look up */
double *red, *green, *blue; /* Color data to return */
{
*red = (double) GetRValue(pixel) / 255.0;
*green = (double) GetGValue(pixel) / 255.0;
*blue = (double) GetBValue(pixel) / 255.0;
}
#else
static void
TkImageGetColor(cdata, pixel, red, green, blue)
TkColormapData *cdata; /* Colormap data */
unsigned long pixel; /* Pixel value to look up */
double *red, *green, *blue; /* Color data to return */
{
if (cdata->separated) {
int r = GetRValue(pixel);
int g = GetGValue(pixel);
int b = GetBValue(pixel);
*red = cdata->colors[r].red / 65535.0;
*green = cdata->colors[g].green / 65535.0;
*blue = cdata->colors[b].blue / 65535.0;
} else {
*red = cdata->colors[pixel].red / 65535.0;
*green = cdata->colors[pixel].green / 65535.0;
*blue = cdata->colors[pixel].blue / 65535.0;
}
}
#endif
/*
*--------------------------------------------------------------
*
* ZnPostscriptXImage --
*
* This procedure is called to output the contents of an
PostScript.c view on Meta::CPAN
{
TkPostscriptInfo *psi = (TkPostscriptInfo *) psInfo;
char buffer[256];
int xx, yy, band, maxRows;
double red, green, blue;
int bytesPerLine=0, maxWidth=0;
int level = psi->colorLevel;
Colormap cmap;
int i, ncolors;
Visual *visual;
TkColormapData cdata;
if (psi->prepass) {
return TCL_OK;
}
Tcl_AppendResult(interp, "%%%%%% Start of ZnPostscriptXImage\n", NULL);
cmap = Tk_Colormap(tkwin);
visual = Tk_Visual(tkwin);
/*
* Obtain information about the colormap, ie the mapping between
* pixel values and RGB values. The code below should work
* for all Visual types.
*/
ncolors = visual->map_entries;
cdata.colors = (XColor *) ckalloc(sizeof(XColor) * ncolors);
cdata.ncolors = ncolors;
if ((visual->class == DirectColor) || (visual->class == TrueColor)) {
cdata.separated = 1;
cdata.red_mask = visual->red_mask;
cdata.green_mask = visual->green_mask;
cdata.blue_mask = visual->blue_mask;
cdata.red_shift = 0;
cdata.green_shift = 0;
cdata.blue_shift = 0;
while ((0x0001 & (cdata.red_mask >> cdata.red_shift)) == 0) {
cdata.red_shift ++;
}
while ((0x0001 & (cdata.green_mask >> cdata.green_shift)) == 0) {
cdata.green_shift ++;
}
while ((0x0001 & (cdata.blue_mask >> cdata.blue_shift)) == 0) {
cdata.blue_shift ++;
}
for (i = 0; i < ncolors; i ++) {
cdata.colors[i].pixel = ((i << cdata.red_shift) & cdata.red_mask) |
((i << cdata.green_shift) & cdata.green_mask) |
((i << cdata.blue_shift) & cdata.blue_mask);
}
}
else {
cdata.separated=0;
for (i = 0; i < ncolors; i ++) {
cdata.colors[i].pixel = i;
}
}
if ((visual->class == StaticGray) || (visual->class == GrayScale)) {
cdata.color = 0;
}
else {
cdata.color = 1;
}
XQueryColors(Tk_Display(tkwin), cmap, cdata.colors, ncolors);
/*
* Figure out which color level to use (possibly lower than the
* one specified by the user). For example, if the user specifies
* color with monochrome screen, use gray or monochrome mode instead.
*/
if (!cdata.color && level == 2) {
level = 1;
}
if (!cdata.color && cdata.ncolors == 2) {
level = 0;
}
/*
* Check that at least one row of the image can be represented
* with a string less than 64 KB long (this is a limit in the
* Postscript interpreter).
*/
switch (level) {
case 0: bytesPerLine = (width + 7) / 8; maxWidth = 240000; break;
case 1: bytesPerLine = width; maxWidth = 60000; break;
case 2: bytesPerLine = 3 * width; maxWidth = 20000; break;
}
if (bytesPerLine > 60000) {
Tcl_ResetResult(interp);
sprintf(buffer, "Can't generate Postscript for images more than %d pixels wide", maxWidth);
Tcl_AppendResult(interp, buffer, (char *) NULL);
ckfree((char *) cdata.colors);
return TCL_ERROR;
}
maxRows = 60000 / bytesPerLine;
for (band = height-1; band >= 0; band -= maxRows) {
int rows = (band >= maxRows) ? maxRows : band + 1;
int lineLen = 0;
switch (level) {
case 0:
PostScript.c view on Meta::CPAN
case 0:
{
/*
* Generate data for image in monochrome mode.
* No attempt at dithering is made--instead, just
* set a threshold.
*/
unsigned char mask=0x80;
unsigned char data=0x00;
for (xx = x; xx< x+width; xx++) {
TkImageGetColor(&cdata, XGetPixel(ximage, xx, yy),
&red, &green, &blue);
if (0.30 * red + 0.59 * green + 0.11 * blue > 0.5)
data |= mask;
mask >>= 1;
if (mask == 0) {
sprintf(buffer, "%02X", data);
Tcl_AppendResult(interp, buffer, (char *) NULL);
lineLen += 2;
if (lineLen > 60) {
lineLen = 0;
PostScript.c view on Meta::CPAN
}
break;
}
case 1:
{
/*
* Generate data in gray mode--in this case, take a
* weighted sum of the red, green, and blue values.
*/
for (xx = x; xx < x+width; xx ++) {
TkImageGetColor(&cdata, XGetPixel(ximage, xx, yy),
&red, &green, &blue);
sprintf(buffer, "%02X", (int) floor(0.5 + 255.0 *
(0.30 * red + 0.59 * green + 0.11 * blue)));
Tcl_AppendResult(interp, buffer, (char *) NULL);
lineLen += 2;
if (lineLen > 60) {
lineLen = 0;
Tcl_AppendResult(interp, "\n", (char *) NULL);
}
}
break;
}
case 2:
{
/*
* Finally, color mode. Here, just output the red, green,
* and blue values directly.
*/
for (xx = x; xx < x+width; xx++) {
TkImageGetColor(&cdata, XGetPixel(ximage, xx, yy),
&red, &green, &blue);
sprintf(buffer, "%02X%02X%02X",
(int) floor(0.5 + 255.0 * red),
(int) floor(0.5 + 255.0 * green),
(int) floor(0.5 + 255.0 * blue));
Tcl_AppendResult(interp, buffer, (char *) NULL);
lineLen += 6;
if (lineLen > 60) {
lineLen = 0;
Tcl_AppendResult(interp, "\n", (char *) NULL);
PostScript.c view on Meta::CPAN
}
switch (level) {
case 0: sprintf(buffer, ">\n} image\n"); break;
case 1: sprintf(buffer, ">\n} image\n"); break;
case 2: sprintf(buffer, ">\n} false 3 colorimage\n"); break;
}
Tcl_AppendResult(interp, buffer, (char *) NULL);
sprintf(buffer, "0 %d translate\n", rows);
Tcl_AppendResult(interp, buffer, (char *) NULL);
}
ckfree((char *) cdata.colors);
Tcl_AppendResult(interp, "%%%%%% End of ZnPostscriptXImage\n", NULL);
return TCL_OK;
}
/*
*--------------------------------------------------------------
*
* ZnPostscriptPhoto --
//printf("Fin de fragment %d, num points: %d\n", num, size);
}
static void CALLBACK
ZnTessCombine(GLdouble coords[3],
void *vertex_data[4],
GLfloat weight[4],
void **out_data,
void *data)
{
ZnCombineData *cdata;
cdata = ZnMalloc(sizeof(ZnCombineData));
cdata->v[0] = coords[0];
cdata->v[1] = coords[1];
cdata->next = ZnTesselator.combine_list;
ZnTesselator.combine_list = cdata;
*out_data = &cdata->v;
ZnTesselator.combine_length++;
//printf("Création d'un nouveau sommet en %g %g\n",
//cdata->v[0], cdata->v[1]);
}
static void CALLBACK
ZnTessError(GLenum errno,
void *data)
{
fprintf(stderr, "Tesselation error in curve item: %d\n", errno);
}
( run in 0.262 second using v1.01-cache-2.11-cpan-454fe037f31 )