void iupPlotDataSet::DrawSelection(const iupPlotTrafoBase *inTrafoX, const iupPlotTrafoBase *inTrafoY, cdCanvas* canvas, const iupPlotSampleNotify* inNotify) const
{
int theCount = mDataX->GetCount();
cdCanvasMarkSize(canvas, 7);
for (int i = 0; i < theCount; i++)
{
if (mSelection->GetSampleBool(i))
{
double theX = mDataX->GetSample(i);
double theY = mDataY->GetSample(i);
double theScreenX = inTrafoX->Transform(theX);
double theScreenY = inTrafoY->Transform(theY);
if (inNotify->cb)
{
int ret = inNotify->cb(inNotify->ih, inNotify->ds, i, theX, theY, (int)mSelection->GetSampleBool(i));
if (ret == IUP_IGNORE)
continue;
}
cdCanvasMarkType(canvas, CD_BOX);
cdCanvasSetForeground(canvas, cdEncodeAlpha(CD_GRAY, 128));
cdfCanvasMark(canvas, theScreenX, theScreenY);
cdCanvasMarkType(canvas, CD_HOLLOW_BOX);
cdCanvasSetForeground(canvas, cdEncodeAlpha(CD_BLACK, 128));
cdfCanvasMark(canvas, theScreenX, theScreenY);
}
}
}
long iupPlot::GetNextDataSetColor()
{
int def_color = 0, i = 0;
long theColor;
do
{
theColor = iPlotGetDefaultColor(def_color);
for (i = 0; i<mDataSetListCount; i++)
{
// already used, get another
long theDataSetColor = cdEncodeAlpha(mDataSetList[i]->mColor, 255);
if (theDataSetColor == theColor)
break;
}
// not found, use it
if (i == mDataSetListCount)
break;
def_color++;
} while (def_color<12);
return theColor;
}
//void SimpleDrawTest(cdCanvas* canvas)
void SimpleDrawPoly(cdCanvas* canvas)
{
int w, h;
cdGetCanvasSize(&w, &h, 0, 0);
cdBackground(CD_WHITE);
cdClear();
//cdSetAttribute("ANTIALIAS", "0");
cdForeground(cdEncodeAlpha(cdEncodeColor(255, 0, 0), 100));
cdfCanvasArc(cdActiveCanvas(), 255, 255, 100, 100, 0, 360);
cdLine(0, 0, 200, 200);
cdBegin(CD_BEZIER);
cdVertex(100, 100);
cdVertex(150, 200);
cdVertex(180, 250);
cdVertex(180, 200);
cdVertex(180, 150);
cdVertex(150, 100);
cdVertex(300, 100);
cdEnd();
cdEnd();
}
void iupPlot::DrawInactive(cdCanvas* canvas) const
{
cdCanvasOrigin(canvas, 0, 0);
cdCanvasClip(canvas, CD_CLIPOFF);
long inactive_color = cdEncodeAlpha(CD_GRAY, 96);
cdCanvasSetForeground(canvas, inactive_color);
cdCanvasBox(canvas, mViewportBack.mX, mViewportBack.mX + mViewportBack.mWidth - 1, mViewportBack.mY, mViewportBack.mY + mViewportBack.mHeight - 1);
}
static int iColorBrowserDlgSetAlphaAttrib(Ihandle* ih, const char* value)
{
IcolorDlgData* colordlg_data = (IcolorDlgData*)iupAttribGetInherit(ih, "_IUP_GC_DATA");
int alpha;
if (iupStrToInt(value, &alpha))
{
colordlg_data->alpha = (unsigned char)alpha;
IupSetInt(colordlg_data->alpha_txt, "VALUE", (int)colordlg_data->alpha);
IupSetInt(colordlg_data->alpha_val, "VALUE", (int)colordlg_data->alpha);
colordlg_data->color = cdEncodeAlpha(colordlg_data->color, colordlg_data->alpha);
colordlg_data->previous_color = cdEncodeAlpha(colordlg_data->previous_color, colordlg_data->alpha);
iColorBrowserDlgColorCnvRepaint(colordlg_data);
if (!ih->handle) /* do it only before map */
IupSetAttribute(ih, "SHOWALPHA", "YES");
}
return 1;
}
/*****************************************\
* Sets the RGB color in the Color Canvas *
\*****************************************/
static void iColorBrowserDlgColor_Update(IcolorDlgData* colordlg_data)
{
colordlg_data->color = cdEncodeColor(colordlg_data->red, colordlg_data->green, colordlg_data->blue);
colordlg_data->color = cdEncodeAlpha(colordlg_data->color, colordlg_data->alpha);
iColorBrowserDlgColorCnvRepaint(colordlg_data);
{
Ihandle* ih = IupGetDialog(colordlg_data->color_browser);
Icallback cb = IupGetCallback(ih, "COLORUPDATE_CB");
if (cb) cb(ih);
}
}
static int iColorBrowserDlgAlphaSpin_CB(Ihandle* ih, int vi)
{
IcolorDlgData* colordlg_data = (IcolorDlgData*)iupAttribGetInherit(ih, "_IUP_GC_DATA");
colordlg_data->alpha = (unsigned char)vi;
IupSetInt(colordlg_data->alpha_val, "VALUE", (int)colordlg_data->alpha);
colordlg_data->color = cdEncodeAlpha(colordlg_data->color, colordlg_data->alpha);
iColorBrowserDlgColorCnvRepaint(colordlg_data);
return IUP_DEFAULT;
}
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 int iColorBrowserDlgSetValueHexAttrib(Ihandle* ih, const char* value)
{
IcolorDlgData* colordlg_data = (IcolorDlgData*)iupAttribGetInherit(ih, "_IUP_GC_DATA");
if (!iupStrToRGB(value, &(colordlg_data->red), &(colordlg_data->green), &(colordlg_data->blue)))
return 0;
colordlg_data->previous_color = cdEncodeColor(colordlg_data->red, colordlg_data->green, colordlg_data->blue);
colordlg_data->previous_color = cdEncodeAlpha(colordlg_data->previous_color, colordlg_data->alpha);
iColorBrowserDlgRGB2HSI(colordlg_data);
iColorBrowserDlgBrowserRGB_Update(colordlg_data);
iColorBrowserDlgHSI_TXT_Update(colordlg_data);
iColorBrowserDlgRGB_TXT_Update(colordlg_data);
iColorBrowserDlgColor_Update(colordlg_data);
return 0;
}
static void iPlotDrawHighlightedMark(cdCanvas *canvas, double x, double y)
{
int foreground = cdCanvasForeground(canvas, CD_QUERY);
int highlightColor = cdEncodeAlpha(foreground, HIGHTLIGHT_ALPHA);
int size = cdCanvasMarkSize(canvas, CD_QUERY);
int type = cdCanvasMarkType(canvas, CD_QUERY);
cdCanvasMarkSize(canvas, size + HIGHTLIGHT_OFFSET);
cdCanvasMarkType(canvas, CD_CIRCLE);
cdCanvasSetForeground(canvas, highlightColor);
cdfCanvasMark(canvas, x, y);
cdCanvasSetForeground(canvas, foreground);
cdCanvasMarkSize(canvas, size);
cdCanvasMarkType(canvas, type);
}
static void iPlotDrawHighlightedArc(cdCanvas *canvas, double xc, double yc, double w, double h, double startAngle, double endAngle)
{
int foreground = cdCanvasForeground(canvas, CD_QUERY);
int highlightColor = cdEncodeAlpha(foreground, HIGHTLIGHT_ALPHA);
int width = cdCanvasLineWidth(canvas, CD_QUERY);
int style = cdCanvasLineStyle(canvas, CD_QUERY);
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
cdCanvasLineWidth(canvas, width + HIGHTLIGHT_OFFSET);
cdCanvasSetForeground(canvas, highlightColor);
cdfCanvasArc(canvas, xc, yc, w, h, startAngle, endAngle);
cdCanvasLineStyle(canvas, style);
cdCanvasLineWidth(canvas, width);
cdCanvasSetForeground(canvas, foreground);
}
static void iPlotDrawHighlightedBar(cdCanvas *canvas, double x, double y, double barWidth, double barHeight)
{
int foreground = cdCanvasForeground(canvas, CD_QUERY);
int highlightColor = cdEncodeAlpha(foreground, HIGHTLIGHT_ALPHA);
int width = cdCanvasLineWidth(canvas, CD_QUERY);
int style = cdCanvasLineStyle(canvas, CD_QUERY);
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
cdCanvasLineWidth(canvas, width + HIGHTLIGHT_OFFSET);
cdCanvasSetForeground(canvas, highlightColor);
iPlotDrawRect(canvas, x, y, barWidth, barHeight);
cdCanvasLineStyle(canvas, style);
cdCanvasLineWidth(canvas, width);
cdCanvasSetForeground(canvas, foreground);
}
static void iPlotDrawHighlightedLine(cdCanvas *canvas, double x1, double y1, double x2, double y2)
{
int foreground = cdCanvasForeground(canvas, CD_QUERY);
int highlightColor = cdEncodeAlpha(foreground, HIGHTLIGHT_ALPHA);
int width = cdCanvasLineWidth(canvas, CD_QUERY);
int style = cdCanvasLineStyle(canvas, CD_QUERY);
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
cdCanvasLineWidth(canvas, width + HIGHTLIGHT_OFFSET);
cdCanvasSetForeground(canvas, highlightColor);
cdfCanvasLine(canvas, x1, y1, x2, y2);
cdCanvasSetForeground(canvas, foreground);
cdCanvasLineStyle(canvas, style);
cdCanvasLineWidth(canvas, width);
}
static int iColorBrowserDlgAlphaAction_CB(Ihandle* ih, int c, char* value)
{
IcolorDlgData* colordlg_data = (IcolorDlgData*)iupAttribGetInherit(ih, "_IUP_GC_DATA");
int vi;
if (iupStrToInt(value, &vi))
{
colordlg_data->alpha = (unsigned char)vi;
IupSetInt(colordlg_data->alpha_val, "VALUE", (int)colordlg_data->alpha);
colordlg_data->color = cdEncodeAlpha(colordlg_data->color, colordlg_data->alpha);
iColorBrowserDlgColorCnvRepaint(colordlg_data);
}
(void)c;
return IUP_DEFAULT;
}
static int iColorBrowserDlgColorSelDrag_CB(Ihandle* ih, unsigned char r, unsigned char g, unsigned char b)
{
IcolorDlgData* colordlg_data = (IcolorDlgData*)iupAttribGetInherit(ih, "_IUP_GC_DATA");
colordlg_data->red = r;
colordlg_data->green = g;
colordlg_data->blue = b;
iColorBrowserDlgRGB2HSI(colordlg_data);
iColorBrowserDlgHex_TXT_Update(colordlg_data);
iColorBrowserDlgHSI_TXT_Update(colordlg_data);
iColorBrowserDlgRGB_TXT_Update(colordlg_data);
colordlg_data->color = cdEncodeColor(colordlg_data->red,colordlg_data->green,colordlg_data->blue);
colordlg_data->color = cdEncodeAlpha(colordlg_data->color, colordlg_data->alpha);
iColorBrowserDlgColorCnvRepaint(colordlg_data);
return IUP_DEFAULT;
}
static int iColorBrowserDlgSetValueHSIAttrib(Ihandle* ih, const char* value)
{
IcolorDlgData* colordlg_data = (IcolorDlgData*)iupAttribGetInherit(ih, "_IUP_GC_DATA");
int hue, saturation, intensity;
if (!iupStrToHSI_Int(value, &hue, &saturation, &intensity))
return 0;
colordlg_data->hue = (float)hue;
colordlg_data->saturation = (float)saturation/100.0f;
colordlg_data->intensity = (float)intensity/100.0f;
iColorBrowserDlgHSI2RGB(colordlg_data);
colordlg_data->previous_color = cdEncodeColor(colordlg_data->red, colordlg_data->green, colordlg_data->blue);
colordlg_data->previous_color = cdEncodeAlpha(colordlg_data->previous_color, colordlg_data->alpha);
iColorBrowserDlgHSIChanged(colordlg_data);
return 0;
}
static int iColorBrowserDlgSetValueAttrib(Ihandle* ih, const char* value)
{
IcolorDlgData* colordlg_data = (IcolorDlgData*)iupAttribGetInherit(ih, "_IUP_GC_DATA");
int ret = iStrToRGBA(value, &colordlg_data->red, &colordlg_data->green, &colordlg_data->blue, &colordlg_data->alpha);
if (!ret)
return 0;
colordlg_data->previous_color = cdEncodeColor(colordlg_data->red, colordlg_data->green, colordlg_data->blue);
colordlg_data->previous_color = cdEncodeAlpha(colordlg_data->previous_color, colordlg_data->alpha);
if (ret == 4)
{
IupSetInt(colordlg_data->alpha_txt, "VALUE", (int)colordlg_data->alpha);
IupSetInt(colordlg_data->alpha_val, "VALUE", (int)colordlg_data->alpha);
if (!ih->handle) /* do it only before map */
IupSetAttribute(ih, "SHOWALPHA", "YES");
}
iColorBrowserDlgRGB_TXT_Update(colordlg_data);
iColorBrowserDlgRGBChanged(colordlg_data);
return 0;
}
void iupPlotDataSet::DrawDataLine(const iupPlotTrafoBase *inTrafoX, const iupPlotTrafoBase *inTrafoY, cdCanvas* canvas, const iupPlotSampleNotify* inNotify, bool inShowMark, bool inErrorBar) const
{
int theCount = mDataX->GetCount();
cdCanvasBegin(canvas, CD_OPEN_LINES);
for (int i = 0; i < theCount; i++)
{
double theX = mDataX->GetSample(i);
double theY = mDataY->GetSample(i);
double theScreenX = inTrafoX->Transform(theX);
double theScreenY = inTrafoY->Transform(theY);
if (inNotify->cb)
inNotify->cb(inNotify->ih, inNotify->ds, i, theX, theY, (int)mSelection->GetSampleBool(i));
if (inShowMark)
{
if (mExtra)
{
if (inErrorBar)
DrawErrorBar(inTrafoY, canvas, i, theY, theScreenX);
else
SetSampleExtraMarkSize(inTrafoY, canvas, i);
}
// No problem that will be drawn before the polygon, they both should have the same color
cdfCanvasMark(canvas, theScreenX, theScreenY);
}
if (i == mHighlightedSample)
iPlotDrawHighlightedMark(canvas, theScreenX, theScreenY);
if (i > 0 && mSegment && mSegment->GetSampleBool(i))
{
cdCanvasEnd(canvas);
cdCanvasBegin(canvas, CD_OPEN_LINES);
}
cdfCanvasVertex(canvas, theScreenX, theScreenY);
}
cdCanvasEnd(canvas);
if (mHighlightedCurve)
{
int foreground = cdCanvasForeground(canvas, CD_QUERY);
int highlightColor = cdEncodeAlpha(foreground, HIGHTLIGHT_ALPHA);
int width = cdCanvasLineWidth(canvas, CD_QUERY);
int style = cdCanvasLineStyle(canvas, CD_QUERY);
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
cdCanvasLineWidth(canvas, width + HIGHTLIGHT_OFFSET);
cdCanvasSetForeground(canvas, highlightColor);
cdCanvasBegin(canvas, CD_OPEN_LINES);
for (int i = 0; i < theCount; i++)
{
double theX = mDataX->GetSample(i);
double theY = mDataY->GetSample(i);
double theScreenX = inTrafoX->Transform(theX);
double theScreenY = inTrafoY->Transform(theY);
if (i > 0 && mSegment && mSegment->GetSampleBool(i))
{
cdCanvasEnd(canvas);
cdCanvasBegin(canvas, CD_OPEN_LINES);
}
cdfCanvasVertex(canvas, theScreenX, theScreenY);
}
cdCanvasEnd(canvas);
cdCanvasSetForeground(canvas, foreground);
cdCanvasLineStyle(canvas, style);
cdCanvasLineWidth(canvas, width);
}
}
void iupPlotDataSet::DrawDataStep(const iupPlotTrafoBase *inTrafoX, const iupPlotTrafoBase *inTrafoY, cdCanvas* canvas, const iupPlotSampleNotify* inNotify) const
{
int theCount = mDataX->GetCount();
cdCanvasBegin(canvas, CD_OPEN_LINES);
double theLastScreenX = 0.;
for (int i = 0; i < theCount; i++)
{
double theX = mDataX->GetSample(i);
double theY = mDataY->GetSample(i);
double theScreenX = inTrafoX->Transform(theX);
double theScreenY = inTrafoY->Transform(theY);
if (inNotify->cb)
inNotify->cb(inNotify->ih, inNotify->ds, i, theX, theY, (int)mSelection->GetSampleBool(i));
if (i > 0 && mSegment && mSegment->GetSampleBool(i))
{
cdCanvasEnd(canvas);
cdCanvasBegin(canvas, CD_OPEN_LINES);
}
if (i > 0)
cdfCanvasVertex(canvas, theLastScreenX, theScreenY);
cdfCanvasVertex(canvas, theScreenX, theScreenY);
if (i == mHighlightedSample)
iPlotDrawHighlightedMark(canvas, theScreenX, theScreenY);
theLastScreenX = theScreenX;
}
cdCanvasEnd(canvas);
if (mHighlightedCurve)
{
int foreground = cdCanvasForeground(canvas, CD_QUERY);
int highlightColor = cdEncodeAlpha(foreground, HIGHTLIGHT_ALPHA);
int width = cdCanvasLineWidth(canvas, CD_QUERY);
int style = cdCanvasLineStyle(canvas, CD_QUERY);
cdCanvasLineStyle(canvas, CD_CONTINUOUS);
cdCanvasLineWidth(canvas, width + HIGHTLIGHT_OFFSET);
cdCanvasSetForeground(canvas, highlightColor);
cdCanvasBegin(canvas, CD_OPEN_LINES);
for (int i = 0; i < theCount; i++)
{
double theX = mDataX->GetSample(i);
double theY = mDataY->GetSample(i);
double theScreenX = inTrafoX->Transform(theX);
double theScreenY = inTrafoY->Transform(theY);
if (i > 0 && mSegment && mSegment->GetSampleBool(i))
{
cdCanvasEnd(canvas);
cdCanvasBegin(canvas, CD_OPEN_LINES);
}
if (i > 0)
cdfCanvasVertex(canvas, theLastScreenX, theScreenY);
cdfCanvasVertex(canvas, theScreenX, theScreenY);
theLastScreenX = theScreenX;
}
cdCanvasEnd(canvas);
cdCanvasSetForeground(canvas, foreground);
cdCanvasLineStyle(canvas, style);
cdCanvasLineWidth(canvas, width);
}
}
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);
}
