void MythUISimpleText::DrawSelf(MythPainter *p, int xoffset, int yoffset,
int alphaMod, QRect clipRect)
{
QRect area = GetArea().toQRect();
area.translate(xoffset, yoffset);
int alpha = CalcAlpha(alphaMod);
p->SetClipRect(clipRect);
p->DrawText(area, m_Message, m_Justification, m_Font, alpha, area);
}
void MythUIText::DrawSelf(MythPainter *p, int xoffset, int yoffset,
int alphaMod, QRect clipRect)
{
QRect area = GetArea().toQRect();
area.translate(xoffset, yoffset);
QRect drawrect = m_drawRect.toQRect();
drawrect.translate(xoffset, yoffset);
int alpha = CalcAlpha(alphaMod);
p->DrawText(drawrect, m_CutMessage, m_Justification, *m_Font, alpha, area);
}
/**
* Отрисовка отметок дальности
*/
void PRL::DrawRange(void)const
{
if(Current.range->isEmpty())
return;
qreal alpha;
//focus=settings["system"]["focus"].toDouble(),
//brightness=settings["brightness"]["range"].isValid() ? settings["brightness"]["range"].toDouble() : 1.0f;
//brightness*=settings["system"]["brightness"].toDouble();
QColor color=ray_color;
for(QVector<RoundLine>::const_iterator it=(*Current.range).begin(),end=(*Current.range).end();it<end;it++)
{
glLineWidth(it->width/**focus*/);
glBegin(GL_LINE_STRIP);
for(Points *i=it->Coordinates,*e=it->Coordinates+ROUND_DEGREE;i<e;i++)
{
alpha=CalcAlpha(i->angle);
if(alpha>.0f)
{
//alpha=alpha<settings["system"]["lightning"].toDouble() ? 1.0f : settings["system"]["lightning"].toDouble()/alpha;
alpha=0.1/alpha;
if(alpha>1.0f)
alpha=1.0f;
color.setAlphaF(alpha/**brightness*/);
qglColor(color);
glVertex2f(i->x,i->y);
}
}
glEnd();
}
/*
for(QVector<RoundLine>::const_iterator it=Cache.range[scale].begin(),end=Cache.range[scale].end();it<end;it++)
{
glLineWidth(it->width);
glBegin(GL_LINE_STRIP);
for(Points *i=it->Coordinates,*e=it->Coordinates+ROUND_DEGREE;i<e;i++)
glVertex2f(i->x,i->y);
glEnd();
}
*/
}
void MythUIType::Draw(MythPainter *p, int xoffset, int yoffset, int alphaMod,
QRect clipRect)
{
m_DirtyRegion = QRegion(QRect(0, 0, 0, 0));
if (!m_Visible || m_Vanished)
return;
QRect realArea = m_Area.toQRect();
realArea.translate(xoffset, yoffset);
if (!realArea.intersects(clipRect))
return;
DrawSelf(p, xoffset, yoffset, alphaMod, clipRect);
QList<MythUIType *>::Iterator it;
for (it = m_ChildrenList.begin(); it != m_ChildrenList.end(); ++it)
{
(*it)->Draw(p, xoffset + m_Area.x(), yoffset + m_Area.y(),
CalcAlpha(alphaMod), clipRect);
}
if (p->ShowBorders())
{
static const QBrush nullbrush(Qt::NoBrush);
p->DrawRect(realArea, nullbrush, QPen(m_BorderColor), 255);
if (p->ShowTypeNames())
{
MythFontProperties font;
font.SetFace(QFont("Droid Sans"));
font.SetColor(m_BorderColor);
font.SetPointSize(8);
p->DrawText(realArea, objectName(), 0, font, 255, realArea);
}
}
}
/**
* Отрисовка координат отметок азимута
*/
void PRL::DrawAzimuth(void)const
{
if(Current.azimuth->isEmpty())
return;
qreal alpha;
/*focus=settings["system"]["focus"].toDouble(),
brightness=settings["brightness"]["azimuth"].isValid() ? settings["brightness"]["azimuth"].toDouble() : 1.0f;
brightness*=settings["system"]["brightness"].toDouble();
*/
QColor color=ray_color;
for(QVector<CenterStraightLine>::const_iterator it=Current.azimuth->begin(),end=Current.azimuth->end();it<end;it++)
{
alpha=CalcAlpha(it->Coordinates.angle);
if(alpha>.0f)
{
//alpha=alpha<settings["system"]["lightning"].toDouble() ? 1.0f : settings["system"]["lightning"].toDouble()/alpha;
alpha=0.1/alpha;
if(alpha>1.0f)
alpha=1.0f;
color.setAlphaF(/*brightness**/alpha);
qglColor(color);
glLineWidth(it->width/**focus*/);
glBegin(GL_LINES);
glVertex2f(.0f,.0f);
glVertex2f(it->Coordinates.x,it->Coordinates.y);
glEnd();
}
}
/*
for(QVector<CenterStraightLine>::const_iterator it=Cache.azimuth.begin(),end=Cache.azimuth.end();it<end;it++)
{
glLineWidth(it->width);
glBegin(GL_LINES);
glVertex2f(.0f,.0f);
glVertex2f(it->Coordinates.x,it->Coordinates.y);
glEnd();
}*/
}
void MythUIType::Draw(MythPainter *p, int xoffset, int yoffset, int alphaMod,
QRect clipRect)
{
m_DirtyRegion = QRegion(QRect(0,0,0,0));
if (!m_Visible)
return;
QRect realArea = m_Area.toQRect();
realArea.translate(xoffset, yoffset);
if (!realArea.intersects(clipRect))
return;
DrawSelf(p, xoffset, yoffset, alphaMod, clipRect);
QList<MythUIType *>::Iterator it;
for (it = m_ChildrenList.begin(); it != m_ChildrenList.end(); ++it)
{
(*it)->Draw(p, xoffset + m_Area.x(), yoffset + m_Area.y(),
CalcAlpha(alphaMod), clipRect);
}
}
void MythUIText::DrawSelf(MythPainter *p, int xoffset, int yoffset,
int alphaMod, QRect clipRect)
{
if (m_Canvas.isNull())
return;
FormatVector formats;
QRect drawrect = m_drawRect.toQRect();
drawrect.translate(xoffset, yoffset);
QRect canvas = m_Canvas.toQRect();
int alpha = CalcAlpha(alphaMod);
if (m_Ascent)
{
drawrect.setY(drawrect.y() - m_Ascent);
canvas.moveTop(canvas.y() + m_Ascent);
canvas.setHeight(canvas.height() + m_Ascent);
}
if (m_Descent)
{
drawrect.setHeight(drawrect.height() + m_Descent);
canvas.setHeight(canvas.height() + m_Descent);
}
if (m_leftBearing)
{
drawrect.setX(drawrect.x() + m_leftBearing);
canvas.moveLeft(canvas.x() - m_leftBearing);
canvas.setWidth(canvas.width() - m_leftBearing);
}
if (m_rightBearing)
{
drawrect.setWidth(drawrect.width() - m_rightBearing);
canvas.setWidth(canvas.width() - m_rightBearing);
}
if (GetFontProperties()->hasOutline())
{
QTextLayout::FormatRange range;
QColor outlineColor;
int outlineSize, outlineAlpha;
GetFontProperties()->GetOutline(outlineColor, outlineSize,
outlineAlpha);
outlineColor.setAlpha(outlineAlpha);
MythPoint outline(outlineSize, outlineSize);
outline.NormPoint(); // scale it to screen resolution
QPen pen;
pen.setBrush(outlineColor);
pen.setWidth(outline.x());
range.start = 0;
range.length = m_CutMessage.size();
range.format.setTextOutline(pen);
formats.push_back(range);
drawrect.setX(drawrect.x() - outline.x());
drawrect.setWidth(drawrect.width() + outline.x());
drawrect.setY(drawrect.y() - outline.y());
drawrect.setHeight(drawrect.height() + outline.y());
/* Canvas pos is where the view port (drawrect) pulls from, so
* it needs moved to the right for the left edge to be picked up*/
canvas.moveLeft(canvas.x() + outline.x());
canvas.setWidth(canvas.width() + outline.x());
canvas.moveTop(canvas.y() + outline.y());
canvas.setHeight(canvas.height() + outline.y());
}
if (GetFontProperties()->hasShadow())
{
QPoint shadowOffset;
QColor shadowColor;
int shadowAlpha;
GetFontProperties()->GetShadow(shadowOffset, shadowColor, shadowAlpha);
MythPoint shadow(shadowOffset);
shadow.NormPoint(); // scale it to screen resolution
drawrect.setWidth(drawrect.width() + shadow.x());
drawrect.setHeight(drawrect.height() + shadow.y());
canvas.setWidth(canvas.width() + shadow.x());
canvas.setHeight(canvas.height() + shadow.y());
}
p->DrawTextLayout(canvas, m_Layouts, formats,
*GetFontProperties(), alpha, drawrect);
}
/**
* \copydoc MythUIType::DrawSelf()
*/
void MythUIImage::DrawSelf(MythPainter *p, int xoffset, int yoffset,
int alphaMod, QRect clipRect)
{
m_ImagesLock.lock();
if (m_Images.size() > 0)
{
d->m_UpdateLock.lockForWrite();
if (m_CurPos >= (uint)m_Images.size())
m_CurPos = 0;
if (!m_Images[m_CurPos])
{
unsigned int origPos = m_CurPos;
m_CurPos++;
while (!m_Images[m_CurPos] && m_CurPos != origPos)
{
m_CurPos++;
if (m_CurPos >= (uint)m_Images.size())
m_CurPos = 0;
}
}
QRect area = GetArea().toQRect();
area.translate(xoffset, yoffset);
int alpha = CalcAlpha(alphaMod);
MythImage *currentImage = m_Images[m_CurPos];
if (currentImage)
currentImage->IncrRef();
m_ImagesLock.unlock();
d->m_UpdateLock.unlock();
if (!currentImage)
return;
d->m_UpdateLock.lockForRead();
QRect currentImageArea = currentImage->rect();
if (!m_imageProperties.forceSize.isNull())
area.setSize(area.size().expandedTo(currentImage->size()));
// Centre image in available space, accounting for zoom
int x = 0, y = 0;
QRect visibleImage = m_Effects.GetExtent(currentImageArea.size());
if (area.width() > visibleImage.width())
x = area.width() / 2 + visibleImage.topLeft().x();
if (area.height() > visibleImage.height())
y = area.height() / 2 + visibleImage.topLeft().y();
if ((x > 0 || y > 0))
area.translate(x, y);
QRect srcRect;
m_imageProperties.cropRect.CalculateArea(GetFullArea());
if (!m_imageProperties.cropRect.isEmpty())
srcRect = m_imageProperties.cropRect.toQRect();
else
srcRect = currentImageArea;
p->DrawImage(area, currentImage, srcRect, alpha);
currentImage->DecrRef();
d->m_UpdateLock.unlock();
}
else
m_ImagesLock.unlock();
}
/*
* Apply the alpha matrix computed above to the rows (or columns)
* of the surface. If dirflag is true do the U's (row), else do V's (col).
*/
void
RefineSurface(NurbSurface *src, NurbSurface *dest, unsigned char dirflag)
{
register long i, j, out;
register Point4 *dp, *sp;
long i1, brkPoint, maxj, maxout;
register double tmp;
double **alpha = NULL;
/* Compute the alpha matrix and indexing variables for the requested direction */
if (dirflag)
{
CalcAlpha( src->kvU, dest->kvU, src->numU - 1, dest->numU - src->numU,
src->orderU, &alpha );
maxj = dest->numU;
maxout = src->numV;
}
else
{
CalcAlpha( src->kvV, dest->kvV, src->numV - 1, dest->numV - src->numV,
src->orderV, &alpha );
maxj = dest->numV;
maxout = dest->numU;
}
/* Apply the alpha matrix to the original control points, generating new ones */
for (out = 0; out < maxout; out++)
for (j = 0; j < maxj; j++)
{
if (dirflag)
{
dp = &(dest->points[out][j]);
brkPoint = FindBreakPoint( dest->kvU[j], src->kvU,
src->numU-1, src->orderU );
i1 = MAX( brkPoint - src->orderU + 1, 0 );
sp = &(src->points[out][i1]);
} else {
dp = &(dest->points[j][out]);
brkPoint = FindBreakPoint( dest->kvV[j], src->kvV,
src->numV-1, src->orderV );
i1 = MAX( brkPoint - src->orderV + 1, 0 );
sp = &(src->points[i1][out]);
}
dp->x = 0.0;
dp->y = 0.0;
dp->z = 0.0;
dp->w = 0.0;
for (i = i1; i <= brkPoint; i++)
{
tmp = alpha[i - i1][j];
sp = (dirflag ? &(src->points[out][i]) : &(src->points[i][out]) );
dp->x += tmp * sp->x;
dp->y += tmp * sp->y;
dp->z += tmp * sp->z;
dp->w += tmp * sp->w;
}
}
/* Free up the alpha matrix */
for (i = 0; i <= (dirflag ? src->orderU : src->orderV); i++)
free( alpha[i] );
free( alpha );
}
/**
* \copydoc MythUIType::DrawSelf()
*/
void MythUIImage::DrawSelf(MythPainter *p, int xoffset, int yoffset,
int alphaMod, QRect clipRect)
{
m_ImagesLock.lock();
if (m_Images.size() > 0)
{
d->m_UpdateLock.lockForWrite();
if (m_CurPos >= (uint)m_Images.size())
m_CurPos = 0;
if (!m_Images[m_CurPos])
{
unsigned int origPos = m_CurPos;
m_CurPos++;
while (!m_Images[m_CurPos] && m_CurPos != origPos)
{
m_CurPos++;
if (m_CurPos >= (uint)m_Images.size())
m_CurPos = 0;
}
}
QRect area = GetArea().toQRect();
area.translate(xoffset, yoffset);
int alpha = CalcAlpha(alphaMod);
MythImage *currentImage = m_Images[m_CurPos];
if (currentImage)
currentImage->UpRef();
m_ImagesLock.unlock();
d->m_UpdateLock.unlock();
if (!currentImage)
return;
d->m_UpdateLock.lockForRead();
QRect currentImageArea = currentImage->rect();
if (!m_ForceSize.isNull())
area.setSize(area.size().expandedTo(currentImage->size()));
// Centre image in available space
int x = 0;
int y = 0;
if (area.width() > currentImageArea.width())
x = (area.width() - currentImageArea.width()) / 2;
if (area.height() > currentImageArea.height())
y = (area.height() - currentImageArea.height()) / 2;
if (x > 0 || y > 0)
area.translate(x,y);
QRect srcRect;
m_cropRect.CalculateArea(GetArea());
if (!m_cropRect.isEmpty())
srcRect = m_cropRect.toQRect();
else
srcRect = currentImageArea;
p->DrawImage(area, currentImage, srcRect, alpha);
currentImage->DownRef();
d->m_UpdateLock.unlock();
}
else
m_ImagesLock.unlock();
}
