MythImage *MythPainter::GetImageFromString(const QString &msg,
int flags, const QRect &r,
const MythFontProperties &font)
{
QString incoming = font.GetHash() + QString::number(r.width()) +
QString::number(r.height()) +
QString::number(flags) +
QString::number(font.color().rgba()) + msg;
MythImage *im = NULL;
if (m_StringToImageMap.contains(incoming))
{
m_StringExpireList.remove(incoming);
m_StringExpireList.push_back(incoming);
im = m_StringToImageMap[incoming];
if (im)
im->IncrRef();
}
else
{
im = GetFormatImage();
im->SetFileName(QString("GetImageFromString: %1").arg(msg));
DrawTextPriv(im, msg, flags, r, font);
im->IncrRef();
m_SoftwareCacheSize += im->bytesPerLine() * im->height();
m_StringToImageMap[incoming] = im;
m_StringExpireList.push_back(incoming);
ExpireImages(m_MaxSoftwareCacheSize);
}
return im;
}
MythImage* MythPainter::GetImageFromRect(const QRect &area, int radius,
int ellipse,
const QBrush &fillBrush,
const QPen &linePen)
{
if (area.width() <= 0 || area.height() <= 0)
return NULL;
uint64_t hash1 = ((0xfff & (uint64_t)area.width())) +
((0xfff & (uint64_t)area.height()) << 12) +
((0xff & (uint64_t)fillBrush.style()) << 24) +
((0xff & (uint64_t)linePen.width()) << 32) +
((0xff & (uint64_t)radius) << 40) +
((0xff & (uint64_t)linePen.style()) << 48) +
((0xff & (uint64_t)ellipse) << 56);
uint64_t hash2 = ((0xffffffff & (uint64_t)linePen.color().rgba())) +
((0xffffffff & (uint64_t)fillBrush.color().rgba()) << 32);
QString incoming("R");
if (fillBrush.style() == Qt::LinearGradientPattern && fillBrush.gradient())
{
const QLinearGradient *gradient = static_cast<const QLinearGradient*>(fillBrush.gradient());
if (gradient)
{
incoming = QString::number(
((0xfff & (uint64_t)gradient->start().x())) +
((0xfff & (uint64_t)gradient->start().y()) << 12) +
((0xfff & (uint64_t)gradient->finalStop().x()) << 24) +
((0xfff & (uint64_t)gradient->finalStop().y()) << 36));
QGradientStops stops = gradient->stops();
for (int i = 0; i < stops.size(); i++)
{
incoming += QString::number(
((0xfff * (uint64_t)(stops[i].first * 100))) +
((uint64_t)stops[i].second.rgba() << 12));
}
}
}
incoming += QString::number(hash1) + QString::number(hash2);
MythImage *im = NULL;
if (m_StringToImageMap.contains(incoming))
{
m_StringExpireList.remove(incoming);
m_StringExpireList.push_back(incoming);
im = m_StringToImageMap[incoming];
if (im)
im->IncrRef();
}
else
{
im = GetFormatImage();
im->SetFileName("GetImageFromRect");
DrawRectPriv(im, area, radius, ellipse, fillBrush, linePen);
im->IncrRef();
m_SoftwareCacheSize += (im->bytesPerLine() * im->height());
m_StringToImageMap[incoming] = im;
m_StringExpireList.push_back(incoming);
ExpireImages(m_MaxSoftwareCacheSize);
}
return im;
}
MythImage *MythPainter::GetImageFromTextLayout(const LayoutVector &layouts,
const FormatVector &formats,
const MythFontProperties &font,
QRect &canvas, QRect &dest)
{
LayoutVector::const_iterator Ipara;
QString incoming = QString::number(canvas.x()) +
QString::number(canvas.y()) +
QString::number(canvas.width()) +
QString::number(canvas.height()) +
QString::number(dest.width()) +
QString::number(dest.height()) +
font.GetHash();
for (Ipara = layouts.begin(); Ipara != layouts.end(); ++Ipara)
incoming += (*Ipara)->text();
MythImage *im = NULL;
if (m_StringToImageMap.contains(incoming))
{
m_StringExpireList.remove(incoming);
m_StringExpireList.push_back(incoming);
im = m_StringToImageMap[incoming];
if (im)
im->IncrRef();
}
else
{
im = GetFormatImage();
im->SetFileName("GetImageFromTextLayout");
QImage pm(canvas.size(), QImage::Format_ARGB32_Premultiplied);
pm.fill(0);
QPainter painter(&pm);
if (!painter.isActive())
{
LOG(VB_GENERAL, LOG_ERR, "MythPainter::GetImageFromTextLayout: "
"Invalid canvas.");
return im;
}
QRect clip;
clip.setSize(canvas.size());
QFont tmpfont = font.face();
tmpfont.setStyleStrategy(QFont::OpenGLCompatible);
painter.setFont(tmpfont);
painter.setRenderHint(QPainter::Antialiasing);
if (font.hasShadow())
{
QRect shadowRect;
QPoint shadowOffset;
QColor shadowColor;
int shadowAlpha;
font.GetShadow(shadowOffset, shadowColor, shadowAlpha);
shadowColor.setAlpha(shadowAlpha);
MythPoint shadow(shadowOffset);
shadow.NormPoint(); // scale it to screen resolution
shadowRect = canvas;
shadowRect.translate(shadow.x(), shadow.y());
painter.setPen(shadowColor);
for (Ipara = layouts.begin(); Ipara != layouts.end(); ++Ipara)
(*Ipara)->draw(&painter, shadowRect.topLeft(), formats, clip);
}
painter.setPen(QPen(font.GetBrush(), 0));
for (Ipara = layouts.begin(); Ipara != layouts.end(); ++Ipara)
(*Ipara)->draw(&painter, canvas.topLeft(), formats, clip);
painter.end();
pm.setOffset(canvas.topLeft());
im->Assign(pm.copy(0, 0, dest.width(), dest.height()));
im->IncrRef();
m_SoftwareCacheSize += im->bytesPerLine() * im->height();
m_StringToImageMap[incoming] = im;
m_StringExpireList.push_back(incoming);
ExpireImages(m_MaxSoftwareCacheSize);
}
return im;
}
/**
* \brief Assign a set of MythImages to the widget for animation.
* Use is strongly discouraged, use SetFilepattern() instead.
*
*/
void MythUIImage::SetImages(QVector<MythImage *> *images)
{
Clear();
QWriteLocker updateLocker(&d->m_UpdateLock);
QSize aSize = GetFullArea().size();
m_imageProperties.isThemeImage = false;
QVector<MythImage *>::iterator it;
for (it = images->begin(); it != images->end(); ++it)
{
MythImage *im = (*it);
if (!im)
{
QMutexLocker locker(&m_ImagesLock);
m_Images[m_Images.size()] = im;
continue;
}
im->IncrRef();
QSize forceSize = m_imageProperties.forceSize;
if (!forceSize.isNull())
{
int w = (forceSize.width() <= 0) ? im->width() : forceSize.width();
int h = (forceSize.height() <= 0) ? im->height() : forceSize.height();
im->Resize(QSize(w, h), m_imageProperties.preserveAspect);
}
if (m_imageProperties.isReflected && !im->IsReflected())
im->Reflect(m_imageProperties.reflectAxis,
m_imageProperties.reflectShear,
m_imageProperties.reflectScale,
m_imageProperties.reflectLength,
m_imageProperties.reflectSpacing);
if (m_imageProperties.isGreyscale && !im->isGrayscale())
im->ToGreyscale();
if (m_imageProperties.isOriented && !im->IsOriented() &&
(m_imageProperties.orientation >= 1 &&
m_imageProperties.orientation <= 8))
im->Orientation(m_imageProperties.orientation);
m_ImagesLock.lock();
m_Images[m_Images.size()] = im;
m_ImagesLock.unlock();
aSize = aSize.expandedTo(im->size());
}
SetImageCount(1, m_Images.size());
if (m_imageProperties.forceSize.isNull())
SetSize(aSize);
MythRect rect(GetFullArea());
rect.setSize(aSize);
SetMinArea(rect);
m_CurPos = 0;
m_animatedImage = true;
m_Initiator = m_EnableInitiator;
SetRedraw();
}
static MythImage *LoadImage(MythPainter *painter,
// Must be a copy for thread safety
ImageProperties imProps,
ImageCacheMode cacheMode,
// Included only to check address, could be
// replaced by generating a unique value for
// each MythUIImage object?
const MythUIImage *parent,
bool &aborted,
MythImageReader *imageReader = NULL)
{
QString cacheKey = GenImageLabel(imProps);
if (!PreLoad(cacheKey, parent))
{
aborted = true;
return NULL;
}
QString filename = imProps.filename;
MythImage *image = NULL;
bool bResize = false;
bool bFoundInCache = false;
int w = -1;
int h = -1;
if (!imProps.forceSize.isNull())
{
if (imProps.forceSize.width() != -1)
w = imProps.forceSize.width();
if (imProps.forceSize.height() != -1)
h = imProps.forceSize.height();
bResize = true;
}
if (!imageReader)
{
image = GetMythUI()->LoadCacheImage(filename, cacheKey,
painter, cacheMode);
}
if (image)
{
if (VERBOSE_LEVEL_CHECK(VB_GUI | VB_FILE, LOG_INFO))
{
image->IncrRef();
int cnt = image->DecrRef();
LOG(VB_GUI | VB_FILE, LOG_INFO,
QString("ImageLoader::LoadImage(%1) Found in cache, "
"RefCount = %2")
.arg(cacheKey).arg(cnt));
}
if (imProps.isReflected)
image->setIsReflected(true);
if (imProps.isOriented)
image->setIsOriented(true);
bFoundInCache = true;
}
else
{
LOG(VB_GUI | VB_FILE, LOG_INFO,
QString("ImageLoader::LoadImage(%1) NOT Found in cache. "
"Loading Directly").arg(cacheKey));
image = painter->GetFormatImage();
bool ok = false;
if (imageReader)
ok = image->Load(imageReader);
else
ok = image->Load(filename);
if (!ok)
{
image->DecrRef();
image = NULL;
}
}
if (image && image->isNull())
{
LOG(VB_GUI | VB_FILE, LOG_INFO,
QString("ImageLoader::LoadImage(%1) Image is NULL")
.arg(filename));
image->DecrRef();
image = NULL;
}
if (image && !bFoundInCache)
{
if (imProps.isReflected)
image->Reflect(imProps.reflectAxis, imProps.reflectShear,
imProps.reflectScale, imProps.reflectLength,
imProps.reflectSpacing);
if (imProps.isGreyscale)
image->ToGreyscale();
if (imProps.isOriented)
image->Orientation(imProps.orientation);
// Even if an explicit size wasn't defined this image may still need
// to be scaled because of a difference between the theme resolution
// and the screen resolution. We want to avoid scaling twice.
if (!bResize && imProps.isThemeImage)
{
float wmult; // Width multipler
float hmult; // Height multipler
GetMythUI()->GetScreenSettings(wmult, hmult);
if (wmult != 1.0f || hmult != 1.0f)
{
w = image->size().width() * wmult;
h = image->size().height() * hmult;
bResize = true;
}
}
if (bResize)
image->Resize(QSize(w, h), imProps.preserveAspect);
if (imProps.isMasked)
{
QRect imageArea = image->rect();
QRect maskArea = imProps.GetMaskImageRect();
// Crop the mask to the image
int x = 0;
int y = 0;
if (maskArea.width() > imageArea.width())
x = (maskArea.width() - imageArea.width()) / 2;
if (maskArea.height() > imageArea.height())
y = (maskArea.height() - imageArea.height()) / 2;
if (x > 0 || y > 0)
imageArea.translate(x, y);
QImage mask = imProps.GetMaskImageSubset(imageArea);
image->setAlphaChannel(mask.alphaChannel());
}
if (!imageReader)
GetMythUI()->CacheImage(cacheKey, image);
}
if (image)
image->SetChanged();
PostLoad(cacheKey);
return image;
}
/**
* \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();
}
