void tglDraw(const TVectorRenderData &rd, const TStroke *s, bool pushAttribs) {
assert(s);
if (!s) return;
TStrokeProp *prop = 0;
bool pushedAttribs = false;
try {
TColorStyleP style;
TStroke *stroke = const_cast<TStroke *>(s);
if (rd.m_inkCheckEnabled && s->getStyle() == rd.m_colorCheckIndex) {
static TSolidColorStyle *redColor = new TSolidColorStyle();
redColor->addRef();
redColor->setMainColor(TPixel::Red);
style = redColor;
} else if (rd.m_tcheckEnabled) {
static TSolidColorStyle *color = new TSolidColorStyle();
color->addRef();
color->setMainColor(rd.m_tCheckInk);
style = color;
} else
style = rd.m_palette->getStyle(stroke->getStyle());
if (!rd.m_show0ThickStrokes && isOThick(s) &&
dynamic_cast<TSolidColorStyle *>(
style.getPointer()) // This is probably to exclude
// TCenterlineStrokeStyle-like styles
&& !rd.m_tcheckEnabled) // I wonder why this?
return;
// const TStroke& stroke = *s; //serve???
assert(rd.m_palette);
prop = s->getProp(/*rd.m_palette*/);
/////questo codice stava dentro tstroke::getprop/////////
if (prop) prop->getMutex()->lock();
if (!style->isStrokeStyle() || style->isEnabled() == false) {
if (prop) prop->getMutex()->unlock();
prop = 0;
} else {
// Warning: the following pointers check is conceptually wrong - we
// keep it because the props maintain SMART POINTER-like reference to
// the associated style. This prevents the style from being destroyed
// while still referenced by the prop.
if (!prop || style.getPointer() != prop->getColorStyle()) {
if (prop) prop->getMutex()->unlock();
stroke->setProp(style->makeStrokeProp(stroke));
prop = stroke->getProp();
if (prop) prop->getMutex()->lock();
}
}
//--------- draw ------------
if (!prop) return;
if (pushAttribs) glPushAttrib(GL_ALL_ATTRIB_BITS), pushedAttribs = true;
bool alphaChannel = rd.m_alphaChannel, antialias = rd.m_antiAliasing;
TVectorImagePatternStrokeProp *aux =
dynamic_cast<TVectorImagePatternStrokeProp *>(prop);
if (aux) // gli image pattern vettoriali tornano in questa funzione....non
// facendo il corpo dell'else'si evita di disegnarli due volte!
prop->draw(rd);
else {
if (antialias)
tglEnableLineSmooth(true);
else
tglEnableLineSmooth(false);
if (alphaChannel) {
GLboolean red, green, blue, alpha;
tglGetColorMask(red, green, blue, alpha);
// Draw RGB channels
tglEnableBlending(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColorMask(red, green, blue, GL_FALSE);
prop->draw(rd);
// Draw Matte channel
tglEnableBlending(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, alpha);
prop->draw(rd);
glColorMask(red, green, blue, alpha);
} else {
tglEnableBlending(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
prop->draw(rd);
}
}
if (pushAttribs) glPopAttrib(), pushedAttribs = false;
prop->getMutex()->unlock();
//---------------------
} catch (...) {
if (prop) prop->getMutex()->unlock();
if (pushedAttribs) glPopAttrib();
}
}
void tglDraw(const TVectorRenderData &rd, TRegion *r, bool pushAttribs) {
checkErrorsByGL;
assert(r);
checkErrorsByGL;
if (!r) return;
bool alphaChannel = rd.m_alphaChannel;
checkErrorsByGL;
int j = 0;
bool visible = false;
int colorCount = 0;
TColorStyleP style;
if (rd.m_paintCheckEnabled && r->getStyle() == rd.m_colorCheckIndex) {
static TSolidColorStyle *redColor = new TSolidColorStyle();
redColor->addRef();
redColor->setMainColor(TPixel::Red);
style = redColor;
} else if (rd.m_tcheckEnabled) {
static TSolidColorStyle *color = new TSolidColorStyle();
color->addRef();
color->setMainColor(rd.m_tCheckPaint);
style = color;
} else
style = rd.m_palette->getStyle(r->getStyle());
colorCount = style->getColorParamCount();
if (colorCount == 0) { // for example texture
visible = true;
} else {
visible = false;
for (j = 0; j < colorCount && !visible; j++) {
TPixel32 color = style->getColorParamValue(j);
if (rd.m_cf) color = (*(rd.m_cf))(color);
if (color.m != 0) visible = true;
}
}
if (visible) {
TRegionProp *prop = r->getProp(/*rd.m_palette*/);
/// questo codice satva dentro tregion::getprop/////
int styleId = r->getStyle();
if (styleId) {
// TColorStyle * style = rd.m_palette->getStyle(styleId);
if (!style->isRegionStyle() || style->isEnabled() == false) {
prop = 0;
} else {
// Warning: The same remark of stroke props holds here.
if (!prop || style.getPointer() != prop->getColorStyle()) {
r->setProp(style->makeRegionProp(r));
prop = r->getProp();
}
}
}
////// draw
if (prop) {
if (pushAttribs) glPushAttrib(GL_ALL_ATTRIB_BITS);
tglEnableLineSmooth(true);
//#define DRAW_EDGE_NUMBERS
#ifdef DRAW_EDGE_NUMBERS
glPushMatrix();
tglMultMatrix(rd.m_aff);
switch (Index % 7) {
case 0:
tglColor(TPixel::Red);
break;
case 1:
tglColor(TPixel::Green);
break;
case 2:
tglColor(TPixel::Blue);
break;
case 3:
tglColor(TPixel::Cyan);
break;
case 4:
tglColor(TPixel::Magenta);
break;
case 5:
tglColor(TPixel::Yellow);
break;
case 6:
tglColor(TPixel::Black);
break;
default:
tglColor(TPixel::Red);
break;
}
Index++;
if (rIndex == 2) {
double y = r->getEdge(0)
->m_s
->getThickPoint(
(r->getEdge(0)->m_w0 + r->getEdge(0)->m_w1) / 2.0)
.y;
tglDrawSegment(TPointD(-1000, y), TPointD(1000, y));
}
for (int i = 0; i < (int)r->getEdgeCount(); i++) {
TEdge *e = r->getEdge(i);
TPointD p = e->m_s->getPoint(0.8 * e->m_w0 + 0.2 * e->m_w1);
if (i == 0)
tglDrawText(p,
(QString::number(rIndex) + QString("-0")).toStdString());
else
tglDrawText(p, QString::number(i).toStdString());
if (e->m_index == 3) {
tglColor(TPixel::Black);
TStroke *s = e->m_s;
drawPoint(s->getChunk(0)->getP0(), .3);
tglColor(TPixel::Red);
tglDrawText(s->getChunk(0)->getP0(),
QString::number(0).toStdString());
for (int ii = 0; ii < s->getChunkCount(); ii++) {
drawPoint(s->getChunk(ii)->getP2(), .3);
if (ii < s->getChunkCount() - 1) {
tglColor(TPixel::Red);
tglDrawText(s->getChunk(ii)->getP2(),
QString::number(ii + 1).toStdString());
}
}
}
}
glPopMatrix();
#endif
if (alphaChannel) {
GLboolean red, green, blue, alpha;
tglGetColorMask(red, green, blue, alpha);
// Draw RGB channels
tglEnableBlending(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColorMask(red, green, blue, GL_FALSE);
prop->draw(rd);
// Draw Matte channel
tglEnableBlending(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, alpha);
prop->draw(rd);
glColorMask(red, green, blue, alpha);
} else {
// pezza: in render, le aree fillate dei custom styles sparivano.
if (!rd.m_isOfflineRender || !rd.m_isImagePattern)
tglRgbOnlyColorMask(); // RGB components only
prop->draw(rd);
}
if (pushAttribs) glPopAttrib();
}
}
for (UINT i = 0; i < r->getSubregionCount(); i++)
tglDraw(rd, r->getSubregion(i), pushAttribs);
checkErrorsByGL;
}
