static void update_viewport(Ihandle* ih, cdCanvas *canvas, float posx, float posy)
{
int view_x, view_y, view_w, view_h;
/* The CD viewport is the same area represented by the virtual space of the scrollbar,
but not using the same coordinates. */
/* posy is top-bottom, CD is bottom-top.
invert posy reference (YMAX-DY - POSY) */
posy = WORLD_H-IupGetFloat(ih, "DY") - posy;
if (posy < 0) posy = 0;
if (scale > 0)
{
view_w = WORLD_W*scale;
view_h = WORLD_H*scale;
view_x = (int)(posx*scale);
view_y = (int)(posy*scale);
}
else
{
view_w = WORLD_W/abs(scale);
view_h = WORLD_H/abs(scale);
view_x = (int)(posx/abs(scale));
view_y = (int)(posy/abs(scale));
}
wdCanvasViewport(canvas, -view_x, view_w-1 - view_x, -view_y, view_h-1 - view_y);
}
static void _wdHdcpyDoit(cdCanvas *canvas, cdCanvas *canvas_copy, void (*draw_func)(cdCanvas *canvas_copy))
{
cdCanvas *old_active;
double left, right, bottom, top; /* canvas visualization window */
int canvas_hsize, canvas_vsize; /* canvas sizes in pixels */
int hdcpy_hsize, hdcpy_vsize; /* paper sizes in points */
double canvas_vpr; /* canvas viewport distortion ratio */
double hdcpy_vpr; /* paper viewport distortion ratio */
int xc, yc; /* paper center in pixels */
int xmin, xmax, ymin, ymax; /* paper viewport */
/* Activate canvas visualization surface. */
if (cdCanvasActivate(canvas) != CD_OK) return;
/* Get current canvas window parameters and sizes. */
wdCanvasGetWindow(canvas, &left, &right, &bottom, &top);
cdCanvasGetSize(canvas, &canvas_hsize, &canvas_vsize, 0L, 0L);
/* Activate hardcopy visualization surface. */
if (cdCanvasActivate(canvas_copy) != CD_OK) return;
/* Set window parameters on hardcopy surface. */
wdCanvasWindow(canvas_copy, left, right, bottom, top);
/* Adjust paper viewport, centralized, matching canvas viewport. */
canvas_vpr = (double)canvas_vsize / (double)canvas_hsize;
cdCanvasGetSize(canvas_copy, &hdcpy_hsize, &hdcpy_vsize, 0L, 0L);
hdcpy_vpr = (double)hdcpy_vsize / (double)hdcpy_hsize;
xc = (int)((double)hdcpy_hsize/2.0);
yc = (int)((double)hdcpy_vsize/2.0);
if (canvas_vpr < hdcpy_vpr)
{
xmin = 0;
xmax = hdcpy_hsize;
ymin = yc - (int)((double)hdcpy_hsize*(double)canvas_vpr/2.0);
ymax = yc + (int)((double)hdcpy_hsize*(double)canvas_vpr/2.0);
}
else
{
xmin = xc - (int)((double)hdcpy_vsize/(double)canvas_vpr/2.0);
xmax = xc + (int)((double)hdcpy_vsize/(double)canvas_vpr/2.0);
ymin = 0;
ymax = hdcpy_vsize;
}
cdCanvasClipArea(canvas_copy, xmin, xmax, ymin, ymax);
cdCanvasClip(canvas_copy, CD_CLIPAREA);
wdCanvasViewport(canvas_copy, xmin, xmax, ymin, ymax);
/* for backward compatibility */
old_active = cdActiveCanvas();
cdActivate(canvas_copy);
/* Draw on hardcopy surface. */
draw_func(canvas_copy);
if (old_active) cdActivate(old_active);
}
void cdCanvasRestoreState(cdCanvas* canvas, cdState* state)
{
assert(canvas);
assert(state);
if (!state || !_cdCheckCanvas(canvas)) return;
/* clippling must be done in low level because origin and invert y axis */
canvas->clip_poly_n = state->clip_poly_n;
if (canvas->clip_poly)
{
free(canvas->clip_poly);
canvas->clip_poly = NULL;
}
if (canvas->clip_fpoly)
{
free(canvas->clip_fpoly);
canvas->clip_fpoly = NULL;
}
if (state->clip_poly)
{
int size = state->clip_poly_n*sizeof(cdPoint);
canvas->clip_poly = (cdPoint*)malloc(size);
memcpy(canvas->clip_poly, state->clip_poly, size);
}
if (state->clip_fpoly)
{
int size = state->clip_poly_n*sizeof(cdfPoint);
canvas->clip_fpoly = (cdfPoint*)malloc(size);
memcpy(canvas->clip_fpoly, state->clip_fpoly, size);
}
cdCanvasClip(canvas, CD_CLIPOFF);
if (canvas->clip_fpoly)
canvas->cxFPoly(canvas->ctxcanvas, CD_CLIP, state->clip_fpoly, state->clip_poly_n);
else if (canvas->clip_poly)
canvas->cxPoly(canvas->ctxcanvas, CD_CLIP, state->clip_poly, state->clip_poly_n);
cdCanvasClipArea(canvas, state->clip_rect.xmin, state->clip_rect.xmax, state->clip_rect.ymin, state->clip_rect.ymax);
if (canvas->cxFClipArea)
canvas->cxFClipArea(canvas->ctxcanvas, state->clip_frect.xmin, state->clip_frect.xmax, state->clip_frect.ymin, state->clip_frect.ymax);
else if (canvas->cxClipArea)
canvas->cxClipArea(canvas->ctxcanvas, state->clip_rect.xmin, state->clip_rect.xmax, state->clip_rect.ymin, state->clip_rect.ymax);
cdCanvasClip(canvas, state->clip_mode);
/* regular attributes */
cdCanvasSetBackground(canvas, state->background);
cdCanvasSetForeground(canvas, state->foreground);
cdCanvasBackOpacity(canvas, state->back_opacity);
cdCanvasWriteMode(canvas, state->write_mode);
cdCanvasLineStyle(canvas, state->line_style);
cdCanvasLineWidth(canvas, state->line_width);
cdCanvasLineCap(canvas, state->line_cap);
cdCanvasLineJoin(canvas, state->line_join);
cdCanvasFillMode(canvas, state->fill_mode);
cdCanvasLineStyleDashes(canvas, state->line_dashes, state->line_dashes_count);
cdCanvasHatch(canvas, state->hatch_style);
if (state->stipple) cdCanvasStipple(canvas, state->stipple_w, state->stipple_h, state->stipple);
if (state->pattern) cdCanvasPattern(canvas, state->pattern_w, state->pattern_h, state->pattern);
cdCanvasInteriorStyle(canvas, state->interior_style);
if (state->native_font[0])
cdCanvasNativeFont(canvas, state->native_font);
else
cdCanvasFont(canvas, state->font_type_face, state->font_style, state->font_size);
cdCanvasTextAlignment(canvas, state->text_alignment);
cdCanvasTextOrientation(canvas, state->text_orientation);
cdCanvasMarkType(canvas, state->mark_type);
cdCanvasMarkSize(canvas, state->mark_size);
cdCanvasOrigin(canvas, state->origin.x, state->origin.y);
if (state->use_matrix)
cdCanvasTransform(canvas, state->matrix);
wdCanvasWindow(canvas, state->window.xmin, state->window.xmax, state->window.ymin, state->window.ymax);
wdCanvasViewport(canvas, state->viewport.xmin, state->viewport.xmax, state->viewport.ymin, state->viewport.ymax);
cdCanvasSimulate(canvas, state->sim_mode);
/* complex clipping regions are not saved */
/* driver internal attributes are not saved */
}
void SimpleDrawAll(cdCanvas* canvas)
{
int w, h;
cdCanvasGetSize(canvas, &w, &h, NULL, NULL);
/* Clear the background to be white */
cdCanvasBackground(canvas, CD_WHITE);
// cdBackground(CD_GREEN);
cdCanvasClear(canvas);
/* Draw a reactangle and a polyline at the bottom-left area,
using a thick line with transparency.
Observe that transparency is only supported in a few drivers,
and line join is not supported in the IMAGERGB driver. */
cdCanvasLineWidth(canvas, 3);
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
cdCanvasForeground(canvas, cdEncodeAlpha(CD_DARK_MAGENTA, 128));
cdCanvasRect(canvas, 100, 200, 100, 200);
cdCanvasBegin(canvas, CD_OPEN_LINES);
cdCanvasVertex(canvas, 300, 250);
cdCanvasVertex(canvas, 320, 270);
cdCanvasVertex(canvas, 350, 260);
cdCanvasVertex(canvas, 340, 200);
cdCanvasVertex(canvas, 310, 210);
cdCanvasEnd(canvas);
/* Draw the red diagonal line with a custom line style.
Observe that line styles are not supported in the IMAGERGB driver. */
cdCanvasForeground(canvas, CD_RED);
cdCanvasLineWidth(canvas, 3);
{
int dashes[] = {20, 15, 5, 5};
cdCanvasLineStyleDashes(canvas, dashes, 4);
}
cdCanvasLineStyle(canvas, CD_CUSTOM);
cdCanvasLine(canvas, 0, 0, w-1, h-1);
/* Draw the blue diagonal line with a pre-defined line style.
Observe that the pre-defined line style is dependent on the driver. */
cdCanvasForeground(canvas, CD_BLUE);
cdCanvasLineWidth(canvas, 10);
cdCanvasLineStyle(canvas, CD_DOTTED);
cdCanvasLine(canvas, 0, h-1, w-1, 0);
switch(clipping)
{
case CD_CLIPOFF:
cdCanvasClip(canvas, CD_CLIPOFF);
break;
case CD_CLIPAREA:
/* Defines the clipping area equals the canvas area minus a 100 pixels margin. */
cdCanvasClipArea(canvas, 100, w - 100, 100, h - 100);
cdCanvasClip(canvas, CD_CLIPAREA);
break;
case CD_CLIPPOLYGON:
cdCanvasBegin(canvas, CD_CLIP);
cdCanvasVertex(canvas, 100, 100);
cdCanvasVertex(canvas, w - 100, 100);
cdCanvasVertex(canvas, w / 2, h - 100);
cdCanvasEnd(canvas);
cdCanvasClip(canvas, CD_CLIPPOLYGON);
break;
case CD_CLIPREGION:
cdCanvasTextAlignment(canvas, CD_CENTER);
cdCanvasFont(canvas, "Times", CD_BOLD, 50);
cdCanvasBegin(canvas, CD_REGION);
cdCanvasRegionCombineMode(canvas, CD_UNION);
cdCanvasBox(canvas, 100, 200, 100, 200);
cdCanvasSector(canvas, w/2-50, h/2+50, 150, 150, 0, 360);
cdCanvasSector(canvas, w/2-50, h/2-50, 150, 150, 0, 360);
cdCanvasSector(canvas, w/2+50, h/2+50, 150, 150, 0, 360);
cdCanvasSector(canvas, w/2+50, h/2-50, 150, 150, 0, 360);
cdCanvasRegionCombineMode(canvas, CD_DIFFERENCE);
cdCanvasText(canvas, w/2, h/2, "TEXT");
cdCanvasEnd(canvas);
// cdCanvasOffsetRegion(canvas, -50, 50);
cdCanvasClip(canvas, CD_CLIPREGION);
cdCanvasForeground(canvas, CD_DARK_RED);
cdCanvasBox(canvas, 0,w,0,h);
break;
}
switch(write_mode)
{
case CD_REPLACE:
cdCanvasWriteMode(canvas, CD_REPLACE);
break;
case CD_XOR:
cdCanvasWriteMode(canvas, CD_XOR);
break;
case CD_NOT_XOR:
cdCanvasWriteMode(canvas, CD_NOT_XOR);
break;
}
if (use_transform)
{
cdCanvasTransform(canvas, NULL);
cdCanvasTransformTranslate(canvas, w/2, h/2);
cdCanvasTransformRotate(canvas, 30);
cdCanvasTransformScale(canvas, 0.5, 0.5);
cdCanvasTransformTranslate(canvas, -w/2, -h/2);
}
// cdSetfAttribute("ROTATE", "15 %d %d", w/2, h/2);
/* Reset line style and width */
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
cdCanvasLineWidth(canvas, 1);
// cdBackOpacity(CD_TRANSPARENT);
/* Draw an arc at bottom-left, and a sector at bottom-right.
Notice that counter-clockwise orientation of both. */
cdCanvasInteriorStyle(canvas, CD_SOLID);
cdCanvasForeground(canvas, CD_MAGENTA);
cdCanvasSector(canvas, w-100, 100, 100, 100, 50, 180);
cdCanvasForeground(canvas, CD_RED);
cdCanvasArc(canvas, 100, 100, 100, 100, 50, 180);
/* Draw a solid filled rectangle at center. */
cdCanvasForeground(canvas, CD_YELLOW);
cdCanvasBox(canvas, w/2 - 100, w/2 + 100, h/2 - 100, h/2 + 100);
/* Prepare font for text. */
cdCanvasTextAlignment(canvas, CD_CENTER);
cdCanvasTextOrientation(canvas, 70);
cdCanvasFont(canvas, "Times", CD_BOLD, 24);
/* Draw text at center, with orientation,
and draw its bounding box.
Notice that in some drivers the bounding box is not precise. */
{
int rect[8];
cdCanvasGetTextBounds(canvas, w/2, h/2, "Simple Draw (pçãí)", rect);
cdCanvasForeground(canvas, CD_RED);
cdCanvasBegin(canvas, CD_CLOSED_LINES);
cdCanvasVertex(canvas, rect[0], rect[1]);
cdCanvasVertex(canvas, rect[2], rect[3]);
cdCanvasVertex(canvas, rect[4], rect[5]);
cdCanvasVertex(canvas, rect[6], rect[7]);
cdCanvasEnd(canvas);
}
cdCanvasForeground(canvas, CD_BLUE);
cdCanvasText(canvas, w/2, h/2, "Simple Draw (pçãí)");
cdCanvasTextOrientation(canvas, 0);
/* Prepare World Coordinates */
wdCanvasViewport(canvas, 0,w-1,0,h-1);
if (w>h)
wdCanvasWindow(canvas, 0,(double)w/(double)h,0,1);
else
wdCanvasWindow(canvas, 0,1,0,(double)h/(double)w);
/* Draw a filled blue rectangle in WC */
wdCanvasBox(canvas, 0.20, 0.30, 0.40, 0.50);
cdCanvasForeground(canvas, CD_RED);
/* Draw the diagonal of that rectangle in WC */
wdCanvasLine(canvas, 0.20, 0.40, 0.30, 0.50);
// wdVectorTextDirection(0, 0, 1, 1);
/* Prepare Vector Text in WC. */
wdCanvasVectorCharSize(canvas, 0.07);
// wdVectorText(0.1, 0.4, "ñç áéíóú àèìòù âêîôû äëïöü");
// wdVectorText(0.1, 0.2, "ÑÇ ÁÉÍÓÚ ÀÈÌÒÙ ÂÊÎÔÛ ÄËÏÖÜ");
//{
// int i;
// char t[2];
// char s[10];
// int x = 20;
// int y = 0;
// t[1] = 0;
// for (i = 0; i < 256; i++)
// {
// int dx = 90;
// t[0] = (char)i;
// sprintf(s, "%d", i);
// cdText(x, y, s);
// cdText(x+dx, y, t);
// cdVectorText(x+2*dx, y, t);
//
// x += 3*dx + 2*dx/3;
// if ((i+1) % 7 == 0)
// {
// x = 20;
// y += 90;
// }
// }
//}
/* Draw vector text, and draw its bounding box.
We also use this text to show when we are using a contextplus driver. */
{
double rect[8];
cdCanvasForeground(canvas, CD_RED);
if (contextplus)
wdCanvasGetVectorTextBounds(canvas, "WDj-Plus", 0.25, 0.35, rect);
else
wdCanvasGetVectorTextBounds(canvas, "WDj", 0.25, 0.35, rect);
cdCanvasBegin(canvas, CD_CLOSED_LINES);
wdCanvasVertex(canvas, rect[0], rect[1]);
wdCanvasVertex(canvas, rect[2], rect[3]);
wdCanvasVertex(canvas, rect[4], rect[5]);
wdCanvasVertex(canvas, rect[6], rect[7]);
cdCanvasEnd(canvas);
cdCanvasLineWidth(canvas, 2);
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
if (contextplus)
wdCanvasVectorText(canvas, 0.25, 0.35, "WDj-Plus");
else
wdCanvasVectorText(canvas, 0.25, 0.35, "WDj");
cdCanvasLineWidth(canvas, 1);
}
/* Draw a filled path at center-right (looks like a weird fish).
Notice that in PDF the arc is necessarily a circle arc, and not an ellipse. */
cdCanvasForeground(canvas, CD_GREEN);
cdCanvasBegin(canvas, CD_PATH);
cdCanvasPathSet(canvas, CD_PATH_MOVETO);
cdCanvasVertex(canvas, w/2 + 200, h/2);
cdCanvasPathSet(canvas, CD_PATH_LINETO);
cdCanvasVertex(canvas, w/2 + 230, h/2 + 50);
cdCanvasPathSet(canvas, CD_PATH_LINETO);
cdCanvasVertex(canvas, w/2 + 250, h/2 + 50);
cdCanvasPathSet(canvas, CD_PATH_CURVETO);
cdCanvasVertex(canvas, w/2+150+150, h/2+200-50); /* control point for start */
cdCanvasVertex(canvas, w/2+150+180, h/2+250-50); /* control point for end */
cdCanvasVertex(canvas, w/2+150+180, h/2+200-50); /* end point */
cdCanvasPathSet(canvas, CD_PATH_CURVETO);
cdCanvasVertex(canvas, w/2+150+180, h/2+150-50);
cdCanvasVertex(canvas, w/2+150+150, h/2+100-50);
cdCanvasVertex(canvas, w/2+150+300, h/2+100-50);
cdCanvasPathSet(canvas, CD_PATH_LINETO);
cdCanvasVertex(canvas, w/2+150+300, h/2-50);
cdCanvasPathSet(canvas, CD_PATH_ARC);
cdCanvasVertex(canvas, w/2+300, h/2); /* center */
cdCanvasVertex(canvas, 200, 100); /* width, height */
cdCanvasVertex(canvas, -30*1000, -170*1000); /* start angle, end angle (degrees / 1000) */
// cdCanvasPathSet(canvas, CD_PATH_CLOSE);
// cdCanvasPathSet(canvas, CD_PATH_STROKE);
cdCanvasPathSet(canvas, CD_PATH_FILL);
// cdCanvasPathSet(canvas, CD_PATH_FILLSTROKE);
cdCanvasEnd(canvas);
/* Draw 3 pixels at center left. */
cdCanvasPixel(canvas, 10, h/2+0, CD_RED);
cdCanvasPixel(canvas, 11, h/2+1, CD_GREEN);
cdCanvasPixel(canvas, 12, h/2+2, CD_BLUE);
/* Draw 4 mark types, distributed near each corner. */
cdCanvasForeground(canvas, CD_RED);
cdCanvasMarkSize(canvas, 30);
cdCanvasMarkType(canvas, CD_PLUS);
cdCanvasMark(canvas, 200, 200);
cdCanvasMarkType(canvas, CD_CIRCLE);
cdCanvasMark(canvas, w - 200, 200);
cdCanvasMarkType(canvas, CD_HOLLOW_CIRCLE);
cdCanvasMark(canvas, 200, h - 200);
cdCanvasMarkType(canvas, CD_DIAMOND);
cdCanvasMark(canvas, w - 200, h - 200);
/* Draw all the line style possibilities at bottom.
Notice that they have some small differences between drivers. */
cdCanvasLineWidth(canvas, 1);
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
cdCanvasLine(canvas, 0, 10, w, 10);
cdCanvasLineStyle(canvas, CD_DASHED);
cdCanvasLine(canvas, 0, 20, w, 20);
cdCanvasLineStyle(canvas, CD_DOTTED);
cdCanvasLine(canvas, 0, 30, w, 30);
cdCanvasLineStyle(canvas, CD_DASH_DOT);
cdCanvasLine(canvas, 0, 40, w, 40);
cdCanvasLineStyle(canvas, CD_DASH_DOT_DOT);
cdCanvasLine(canvas, 0, 50, w, 50);
/* Draw all the hatch style possibilities in the top-left corner.
Notice that they have some small differences between drivers. */
cdCanvasHatch(canvas, CD_VERTICAL);
cdCanvasBox(canvas, 0, 50, h - 60, h);
cdCanvasHatch(canvas, CD_FDIAGONAL);
cdCanvasBox(canvas, 50, 100, h - 60, h);
cdCanvasHatch(canvas, CD_BDIAGONAL);
cdCanvasBox(canvas, 100, 150, h - 60, h);
cdCanvasHatch(canvas, CD_CROSS);
cdCanvasBox(canvas, 150, 200, h - 60, h);
cdCanvasHatch(canvas, CD_HORIZONTAL);
cdCanvasBox(canvas, 200, 250, h - 60, h);
cdCanvasHatch(canvas, CD_DIAGCROSS);
cdCanvasBox(canvas, 250, 300, h - 60, h);
/* Draw 4 regions, in diamond shape,
at top, bottom, left, right,
using different interior styles. */
/* At top, not filled polygon, notice that the last line style is used. */
cdCanvasBegin(canvas, CD_CLOSED_LINES);
cdCanvasVertex(canvas, w/2, h - 100);
cdCanvasVertex(canvas, w/2 + 50, h - 150);
cdCanvasVertex(canvas, w/2, h - 200);
cdCanvasVertex(canvas, w/2 - 50, h - 150);
cdCanvasEnd(canvas);
/* At left, hatch filled polygon */
cdCanvasHatch(canvas, CD_DIAGCROSS);
cdCanvasBegin(canvas, CD_FILL);
cdCanvasVertex(canvas, 100, h/2);
cdCanvasVertex(canvas, 150, h/2 + 50);
cdCanvasVertex(canvas, 200, h/2);
cdCanvasVertex(canvas, 150, h/2 - 50);
cdCanvasEnd(canvas);
/* At right, pattern filled polygon */
cdCanvasPattern(canvas, STYLE_SIZE, STYLE_SIZE, pattern);
cdCanvasBegin(canvas, CD_FILL);
cdCanvasVertex(canvas, w - 100, h/2);
cdCanvasVertex(canvas, w - 150, h/2 + 50);
cdCanvasVertex(canvas, w - 200, h/2);
cdCanvasVertex(canvas, w - 150, h/2 - 50);
cdCanvasEnd(canvas);
/* At bottom, stipple filled polygon */
cdCanvasStipple(canvas, STYLE_SIZE, STYLE_SIZE, stipple);
cdCanvasBegin(canvas, CD_FILL);
cdCanvasVertex(canvas, w/2, 100);
cdCanvasVertex(canvas, w/2 + 50, 150);
cdCanvasVertex(canvas, w/2, 200);
cdCanvasVertex(canvas, w/2 - 50, 150);
cdCanvasEnd(canvas);
/* Draw two beziers at bottom-left */
cdCanvasBegin(canvas, CD_BEZIER);
cdCanvasVertex(canvas, 100, 100);
cdCanvasVertex(canvas, 150, 200);
cdCanvasVertex(canvas, 180, 250);
cdCanvasVertex(canvas, 180, 200);
cdCanvasVertex(canvas, 180, 150);
cdCanvasVertex(canvas, 150, 100);
cdCanvasVertex(canvas, 300, 100);
cdCanvasEnd(canvas);
/* Initialize the image buffer contents */
//#define IMAGE_SIZE 16
memset(red, 0xFF, IMAGE_SIZE*IMAGE_SIZE/2);
memset(green, 0x5F, IMAGE_SIZE*IMAGE_SIZE/2);
memset(blue, 0x5F, IMAGE_SIZE*IMAGE_SIZE/2);
memset(red+IMAGE_SIZE*IMAGE_SIZE/2, 0x5F, IMAGE_SIZE*IMAGE_SIZE/2);
memset(green+IMAGE_SIZE*IMAGE_SIZE/2, 0x8F, IMAGE_SIZE*IMAGE_SIZE/2);
memset(blue+IMAGE_SIZE*IMAGE_SIZE/2, 0x5F, IMAGE_SIZE*IMAGE_SIZE/2);
memset(red+IMAGE_SIZE*(IMAGE_SIZE-1), 0, IMAGE_SIZE);
memset(green+IMAGE_SIZE*(IMAGE_SIZE-1), 0, IMAGE_SIZE);
memset(blue+IMAGE_SIZE*(IMAGE_SIZE-1), 0, IMAGE_SIZE);
memset(red, 0, IMAGE_SIZE);
memset(green, 0, IMAGE_SIZE);
memset(blue, 0, IMAGE_SIZE);
{
int i, offset;
for (i = 0; i < IMAGE_SIZE; i++)
{
offset = i*IMAGE_SIZE;
red[offset] = 0;
green[offset] = 0;
blue[offset] = 0;
red[offset+IMAGE_SIZE-1] = 0;
green[offset+IMAGE_SIZE-1] = 0;
blue[offset+IMAGE_SIZE-1] = 0;
}
}
//cdSetAttribute("ANTIALIAS", "0");
// cdGetImageRGB(red, green, blue, w/2 - 50, h/2-50, 100, 100);
// cdPutImageRectRGB(14, 13, red, green, blue, -20, -15, 649, 603, 0, 13, 0, 12);
// cdPutImageRectRGB(16, 16, red, green, blue, 10, 10, 608, 608, 5, 10, 5, 10);
// cdPutImageRectRGB(16, 16, red, green, blue, 10, 10, 64, 64, 5, 10, 5, 10);
// cdPutImageRGB(IMAGE_SIZE, IMAGE_SIZE, red, green, blue, 100, h - 200, IMAGE_SIZE, IMAGE_SIZE);
// cdPutImageRGBA(IMAGE_SIZE, IMAGE_SIZE, red, green, blue, alpha, 100, h - 200, IMAGE_SIZE, IMAGE_SIZE);
// cdPutImageRGB(IMAGE_SIZE, IMAGE_SIZE, red, green, blue, w - 400, h - 310, 3*IMAGE_SIZE, 3*IMAGE_SIZE);
/* Draw the image on the top-right corner but increasing its actual size, and uses its full area */
cdCanvasPutImageRectRGBA(canvas, IMAGE_SIZE, IMAGE_SIZE, red, green, blue, alpha, w - 400, h - 310, 3*IMAGE_SIZE, 3*IMAGE_SIZE, 0, 0, 0, 0);
cdCanvasSetAttribute(canvas, "ROTATE", NULL);
if (use_transform)
cdCanvasTransform(canvas, NULL);
cdCanvasClip(canvas, CD_CLIPOFF);
}
