/**
* \brief Handle one frame of an alpha (transparency) change animation.
*
* This changes the alpha value of the widget
*/
void MythUIType::HandleAlphaPulse(void)
{
if (!GetPainter()->SupportsAlpha() ||
!GetPainter()->SupportsAnimation())
return;
if (m_AlphaChangeMode == 0)
return;
m_Alpha += m_AlphaChange;
if (m_Alpha > m_AlphaMax)
m_Alpha = m_AlphaMax;
if (m_Alpha < m_AlphaMin)
m_Alpha = m_AlphaMin;
// Reached limits so change direction
if (m_Alpha == m_AlphaMax || m_Alpha == m_AlphaMin)
{
if (m_AlphaChangeMode == 2)
{
m_AlphaChange *= -1;
}
else
{
m_AlphaChangeMode = 0;
m_AlphaChange = 0;
}
}
SetRedraw();
}
void SurfaceImpl::FlushCachedState()
{
if (device->paintingActive()) {
GetPainter()->setPen(QPen());
GetPainter()->setBrush(QBrush());
}
}
void SurfaceImpl::DrawTextTransparent(PRectangle rc,
Font &font,
XYPOSITION ybase,
const char *s,
int len,
ColourDesired fore)
{
SetFont(font);
PenColour(fore);
GetPainter()->setBackgroundMode(Qt::TransparentMode);
QString su = codec->toUnicode(s, len);
GetPainter()->drawText(QPointF(rc.left, ybase), su);
}
void SurfaceImpl::SetFont(Font &font)
{
if (font.GetID()) {
GetPainter()->setFont(*FontPointer(font));
SetCodec(font);
}
}
void SurfaceImpl::DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage)
{
std::vector<unsigned char> imageBytes = ImageByteSwapped(width, height, pixelsImage);
QImage image(&imageBytes[0], width, height, QImage::Format_ARGB32);
QPoint pt(rc.left, rc.top);
GetPainter()->drawImage(pt, image);
}
void SurfaceImpl::LineTo(int x_, int y_)
{
QLineF line(x, y, x_, y_);
GetPainter()->drawLine(line);
x = x_;
y = y_;
}
void PCB_BASE_FRAME::OnTogglePadDrawMode( wxCommandEvent& aEvent )
{
DISPLAY_OPTIONS* displ_opts = (DISPLAY_OPTIONS*)GetDisplayOptions();
displ_opts->m_DisplayPadFill = !displ_opts->m_DisplayPadFill;
EDA_DRAW_PANEL_GAL* gal = GetGalCanvas();
if( gal )
{
// Apply new display options to the GAL canvas
auto view = gal->GetView();
auto painter = static_cast<KIGFX::PCB_PAINTER*> ( view->GetPainter() );
auto settings = static_cast<KIGFX::PCB_RENDER_SETTINGS*> ( painter->GetSettings() );
settings->LoadDisplayOptions( displ_opts );
// Update pads
BOARD* board = GetBoard();
for( MODULE* module = board->m_Modules; module; module = module->Next() )
{
for( D_PAD* pad = module->Pads(); pad; pad = pad->Next() )
view->Update( pad, KIGFX::GEOMETRY );
}
}
m_canvas->Refresh();
}
void SurfaceImpl::DrawTextNoClip(PRectangle rc,
Font &font,
XYPOSITION ybase,
const char *s,
int len,
ColourDesired fore,
ColourDesired back)
{
SetFont(font);
PenColour(fore);
GetPainter()->setBackground(QColorFromCA(back));
GetPainter()->setBackgroundMode(Qt::OpaqueMode);
QString su = codec->toUnicode(s, len);
GetPainter()->drawText(QPointF(rc.left, ybase), su);
}
void SurfaceImpl::Copy(PRectangle rc, Point from, Surface &surfaceSource)
{
SurfaceImpl *source = static_cast<SurfaceImpl *>(&surfaceSource);
QPixmap *pixmap = static_cast<QPixmap *>(source->GetPaintDevice());
GetPainter()->drawPixmap(rc.left, rc.top, *pixmap, from.x, from.y, -1, -1);
}
void SurfaceImpl::Ellipse(PRectangle rc,
ColourDesired fore,
ColourDesired back)
{
PenColour(fore);
BrushColour(back);
GetPainter()->drawEllipse(QRectFromPRect(rc));
}
void SurfaceImpl::RectangleDraw(PRectangle rc,
ColourDesired fore,
ColourDesired back)
{
PenColour(fore);
BrushColour(back);
QRect rect = QRect(rc.left, rc.top, rc.Width() - 1, rc.Height() - 1);
GetPainter()->drawRect(rect);
}
void SurfaceImpl::AlphaRectangle(PRectangle rc,
int cornerSize,
ColourDesired fill,
int alphaFill,
ColourDesired outline,
int alphaOutline,
int /*flags*/)
{
QColor qOutline = QColorFromCA(outline);
qOutline.setAlpha(alphaOutline);
GetPainter()->setPen(QPen(qOutline));
QColor qFill = QColorFromCA(fill);
qFill.setAlpha(alphaFill);
GetPainter()->setBrush(QBrush(qFill));
// A radius of 1 shows no curve so add 1
qreal radius = cornerSize+1;
QRect rect(rc.left, rc.top, rc.Width() - 1, rc.Height() - 1);
GetPainter()->drawRoundedRect(rect, radius, radius);
}
void SurfaceImpl::DrawTextClipped(PRectangle rc,
Font &font,
XYPOSITION ybase,
const char *s,
int len,
ColourDesired fore,
ColourDesired back)
{
SetClip(rc);
DrawTextNoClip(rc, font, ybase, s, len, fore, back);
GetPainter()->setClipping(false);
}
void MythUIType::MoveTo(QPoint destXY, QPoint speedXY)
{
if (!GetPainter()->SupportsAnimation())
return;
if (destXY.x() == m_Area.x() && destXY.y() == m_Area.y())
return;
m_Moving = true;
m_XYDestination = destXY;
m_XYSpeed = speedXY;
}
void MythUIType::AdjustAlpha(int mode, int alphachange, int minalpha,
int maxalpha)
{
if (!GetPainter()->SupportsAlpha())
return;
m_AlphaChangeMode = mode;
m_AlphaChange = alphachange;
m_AlphaMin = minalpha;
m_AlphaMax = maxalpha;
if (m_Alpha > m_AlphaMax)
m_Alpha = m_AlphaMax;
if (m_Alpha < m_AlphaMin)
m_Alpha = m_AlphaMin;
}
void SurfaceImpl::Polygon(Point *pts,
int npts,
ColourDesired fore,
ColourDesired back)
{
PenColour(fore);
BrushColour(back);
QPoint *qpts = new QPoint[npts];
for (int i = 0; i < npts; i++) {
qpts[i] = QPoint(pts[i].x, pts[i].y);
}
GetPainter()->drawPolygon(qpts, npts);
delete [] qpts;
}
void SurfaceImpl::FillRectangle(PRectangle rc, Surface &surfacePattern)
{
// Tile pattern over rectangle
SurfaceImpl *surface = static_cast<SurfaceImpl *>(&surfacePattern);
// Currently assumes 8x8 pattern
int widthPat = 8;
int heightPat = 8;
for (int xTile = rc.left; xTile < rc.right; xTile += widthPat) {
int widthx = (xTile + widthPat > rc.right) ? rc.right - xTile : widthPat;
for (int yTile = rc.top; yTile < rc.bottom; yTile += heightPat) {
int heighty = (yTile + heightPat > rc.bottom) ? rc.bottom - yTile : heightPat;
QRect source(0, 0, widthx, heighty);
QRect target(xTile, yTile, widthx, heighty);
QPixmap *pixmap = static_cast<QPixmap *>(surface->GetPaintDevice());
GetPainter()->drawPixmap(target, *pixmap, source);
}
}
}
void MythUIText::CycleColor(QColor startColor, QColor endColor, int numSteps)
{
if (!GetPainter()->SupportsAnimation())
return;
m_startColor = startColor;
m_endColor = endColor;
m_numSteps = numSteps;
m_curStep = 0;
curR = startColor.red();
curG = startColor.green();
curB = startColor.blue();
incR = (endColor.red() * 1.0 - curR) / m_numSteps;
incG = (endColor.green() * 1.0 - curG) / m_numSteps;
incB = (endColor.blue() * 1.0 - curB) / m_numSteps;
m_colorCycling = true;
}
/**
* \brief Handle one frame of a movement animation.
*
* This changes the position of the widget within it's parent's area
*/
void MythUIType::HandleMovementPulse(void)
{
if (!GetPainter()->SupportsAnimation())
return;
if (!m_Moving)
return;
QPoint curXY = m_Area.topLeft().toQPoint();
m_DirtyRegion = m_Area.toQRect();
int xdir = m_XYDestination.x() - curXY.x();
int ydir = m_XYDestination.y() - curXY.y();
curXY.setX(curXY.x() + m_XYSpeed.x());
curXY.setY(curXY.y() + m_XYSpeed.y());
if ((xdir > 0 && curXY.x() >= m_XYDestination.x()) ||
(xdir < 0 && curXY.x() <= m_XYDestination.x()) ||
(xdir == 0))
{
m_XYSpeed.setX(0);
}
if ((ydir > 0 && curXY.y() >= m_XYDestination.y()) ||
(ydir <= 0 && curXY.y() <= m_XYDestination.y()) ||
(ydir == 0))
{
m_XYSpeed.setY(0);
}
SetRedraw();
if (m_XYSpeed.x() == 0 && m_XYSpeed.y() == 0)
{
m_Moving = false;
emit FinishedMoving();
}
m_Area.moveTopLeft(curXY);
}
void GERBER_LAYER_WIDGET::OnRenderColorChange( int aId, COLOR4D aColor )
{
myframe->SetVisibleElementColor( (GERBVIEW_LAYER_ID) aId, aColor );
auto galCanvas = myframe->GetGalCanvas();
if( galCanvas && myframe->IsGalCanvasActive() )
{
auto view = galCanvas->GetView();
view->GetPainter()->GetSettings()->ImportLegacyColors( myframe->m_colorsSettings );
view->UpdateLayerColor( aId );
view->MarkTargetDirty( KIGFX::TARGET_NONCACHED );
view->UpdateAllItems( KIGFX::COLOR );
}
if( galCanvas && myframe->IsGalCanvasActive() )
galCanvas->Refresh();
else
myframe->GetCanvas()->Refresh();
}
/**
* \brief Load the image(s), wraps LoadImage()
*/
bool MythUIImage::Load(bool allowLoadInBackground, bool forceStat)
{
d->m_UpdateLock.lockForRead();
QSize bForceSize = m_ForceSize;
QString bFilename = m_Filename;
bFilename.detach();
d->m_UpdateLock.unlock();
QString filename = bFilename;
if (bFilename.isEmpty())
{
Clear();
SetRedraw();
return false;
}
Clear();
// SetRedraw();
// if (!IsVisible(true))
// return false;
int w = -1;
int h = -1;
if (!bForceSize.isNull())
{
if (bForceSize.width() != -1)
w = bForceSize.width();
if (bForceSize.height() != -1)
h = bForceSize.height();
}
QString imagelabel;
int j = 0;
for (int i = m_LowNum; i <= m_HighNum && !m_animatedImage; i++)
{
if (!m_animatedImage && m_HighNum != m_LowNum &&
bFilename.contains("%1"))
filename = bFilename.arg(i);
imagelabel = GenImageLabel(filename, w, h);
// Only load in the background if allowed and the image is
// not already in our mem cache
ImageCacheMode cacheMode = kCacheCheckMemoryOnly;
if (forceStat)
cacheMode = (ImageCacheMode)
((int)kCacheCheckMemoryOnly | (int)kCacheForceStat);
ImageCacheMode cacheMode2 = (!forceStat) ? kCacheNormal :
(ImageCacheMode) ((int)kCacheNormal | (int)kCacheForceStat);
if ((allowLoadInBackground) &&
(!GetMythUI()->LoadCacheImage(filename, imagelabel,
GetPainter(), cacheMode)) &&
(!getenv("DISABLETHREADEDMYTHUIIMAGE")))
{
VERBOSE(VB_GUI|VB_FILE|VB_EXTRA, LOC + QString(
"Load(), spawning thread to load '%1'").arg(filename));
ImageLoadThread *bImgThread = new ImageLoadThread(
this, bFilename, filename, i, bForceSize, cacheMode2);
GetMythUI()->GetImageThreadPool()->start(bImgThread);
}
else
{
// Perform a blocking load
VERBOSE(VB_GUI|VB_FILE|VB_EXTRA, LOC + QString(
"Load(), loading '%1' in foreground").arg(filename));
QString tmpFilename;
if ((filename.startsWith("/")) ||
(filename.startsWith("http://")) ||
(filename.startsWith("https://")) ||
(filename.startsWith("ftp://")))
tmpFilename = filename;
MythImageReader imageReader(tmpFilename);
if (imageReader.supportsAnimation())
{
LoadAnimatedImage(
imageReader, filename, bForceSize, cacheMode2);
}
else
{
MythImage *image = LoadImage(
imageReader, filename, bForceSize, cacheMode2);
if (image)
{
if (bForceSize.isNull())
SetSize(image->size());
m_ImagesLock.lock();
m_Images[j] = image;
m_ImagesLock.unlock();
SetRedraw();
d->m_UpdateLock.lockForWrite();
m_LastDisplay = QTime::currentTime();
d->m_UpdateLock.unlock();
}
else
{
m_ImagesLock.lock();
m_Images[j] = NULL;
m_ImagesLock.unlock();
}
}
}
++j;
}
return true;
}
void SurfaceImpl::SetClip(PRectangle rc)
{
GetPainter()->setClipRect(QRectFromPRect(rc));
}
bool MythUIText::ParseElement(
const QString &filename, QDomElement &element, bool showWarnings)
{
if (element.tagName() == "area")
{
SetArea(parseRect(element));
m_OrigDisplayRect = m_Area;
}
// else if (element.tagName() == "altarea") // Unused, but maybe in future?
// m_AltDisplayRect = parseRect(element);
else if (element.tagName() == "font")
{
QString fontname = getFirstText(element);
MythFontProperties *fp = GetFont(fontname);
if (!fp)
fp = GetGlobalFontMap()->GetFont(fontname);
if (fp)
{
MythFontProperties font = *fp;
int screenHeight = GetMythMainWindow()->GetUIScreenRect().height();
font.Rescale(screenHeight);
int fontStretch = GetMythUI()->GetFontStretch();
font.AdjustStretch(fontStretch);
QString state = element.attribute("state","");
if (!state.isEmpty())
{
m_FontStates.insert(state, font);
}
else
{
m_FontStates.insert("default", font);
*m_Font = m_FontStates["default"];
}
}
}
else if (element.tagName() == "value")
{
if (element.attribute("lang","").isEmpty())
{
m_Message = qApp->translate("ThemeUI",
parseText(element).toUtf8(), NULL,
QCoreApplication::UnicodeUTF8);
}
else if (element.attribute("lang","").toLower() ==
gCoreContext->GetLanguageAndVariant())
{
m_Message = parseText(element);
}
else if (element.attribute("lang","").toLower() ==
gCoreContext->GetLanguage())
{
m_Message = parseText(element);
}
m_DefaultMessage = m_Message;
SetText(m_Message);
}
else if (element.tagName() == "template")
{
m_TemplateText = parseText(element);
}
else if (element.tagName() == "cutdown")
{
SetCutDown(parseBool(element));
}
else if (element.tagName() == "multiline")
{
SetMultiLine(parseBool(element));
}
else if (element.tagName() == "align")
{
QString align = getFirstText(element).toLower();
SetJustification(parseAlignment(align));
}
else if (element.tagName() == "colorcycle")
{
if (GetPainter()->SupportsAnimation())
{
QString tmp = element.attribute("start");
if (!tmp.isEmpty())
m_startColor = QColor(tmp);
tmp = element.attribute("end");
if (!tmp.isEmpty())
m_endColor = QColor(tmp);
tmp = element.attribute("steps");
if (!tmp.isEmpty())
m_numSteps = tmp.toInt();
// initialize the rest of the stuff
CycleColor(m_startColor, m_endColor, m_numSteps);
}
else
m_colorCycling = false;
m_colorCycling = parseBool(element.attribute("disable"));
}
else if (element.tagName() == "scroll")
{
if (GetPainter()->SupportsAnimation())
{
QString tmp = element.attribute("direction");
if (!tmp.isEmpty())
{
tmp = tmp.toLower();
if (tmp == "left")
m_scrollDirection = ScrollLeft;
else if (tmp == "right")
m_scrollDirection = ScrollRight;
else if (tmp == "up")
m_scrollDirection = ScrollUp;
else if (tmp == "down")
m_scrollDirection = ScrollDown;
}
m_scrolling = true;
}
else
m_scrolling = false;
}
else if (element.tagName() == "case")
{
QString stringCase = getFirstText(element).toLower();
if (stringCase == "lower")
m_textCase = CaseLower;
else if (stringCase == "upper")
m_textCase = CaseUpper;
else if (stringCase == "capitalisefirst")
m_textCase = CaseCapitaliseFirst;
else if (stringCase == "capitaliseall")
m_textCase = CaseCapitaliseAll;
else
m_textCase = CaseNormal;
FillCutMessage();
}
else
{
return MythUIType::ParseElement(filename, element, showWarnings);
}
return true;
}
/**
* \copydoc MythUIType::ParseElement()
*/
bool MythUIImage::ParseElement(
const QString &filename, QDomElement &element, bool showWarnings)
{
QWriteLocker updateLocker(&d->m_UpdateLock);
if (element.tagName() == "filename")
{
m_imageProperties.isThemeImage = true; // This is an image distributed with the them
m_OrigFilename = m_imageProperties.filename = getFirstText(element);
if (m_imageProperties.filename.endsWith('/'))
{
m_showingRandomImage = true;
m_imageDirectory = m_imageProperties.filename;
FindRandomImage();
}
}
else if (element.tagName() == "filepattern")
{
m_imageProperties.isThemeImage = true; // This is an image distributed with the theme
m_OrigFilename = m_imageProperties.filename = getFirstText(element);
QString tmp = element.attribute("low");
if (!tmp.isEmpty())
m_LowNum = tmp.toInt();
tmp = element.attribute("high");
if (!tmp.isEmpty())
m_HighNum = tmp.toInt();
tmp = element.attribute("cycle", "start");
if (tmp == "reverse")
m_animationCycle = kCycleReverse;
}
else if (element.tagName() == "area")
{
SetArea(parseRect(element));
m_imageProperties.forceSize = m_Area.size();
}
else if (element.tagName() == "preserveaspect")
m_imageProperties.preserveAspect = parseBool(element);
else if (element.tagName() == "crop")
m_imageProperties.cropRect = parseRect(element);
else if (element.tagName() == "delay")
{
QString value = getFirstText(element);
if (value.contains(","))
{
QVector<int> delays;
QStringList tokens = value.split(",");
QStringList::iterator it = tokens.begin();
for (; it != tokens.end(); ++it)
{
if ((*it).isEmpty())
{
if (delays.size())
delays.append(delays[delays.size()-1]);
else
delays.append(0); // Default 0ms delay before first image
}
else
{
delays.append((*it).toInt());
}
}
if (delays.size())
{
m_Delay = delays[0];
SetDelays(delays);
}
}
else
{
m_Delay = value.toInt();
}
}
else if (element.tagName() == "reflection")
{
m_imageProperties.isReflected = true;
QString tmp = element.attribute("axis");
if (!tmp.isEmpty())
{
if (tmp.toLower() == "horizontal")
m_imageProperties.reflectAxis = ReflectHorizontal;
else
m_imageProperties.reflectAxis = ReflectVertical;
}
tmp = element.attribute("shear");
if (!tmp.isEmpty())
m_imageProperties.reflectShear = tmp.toInt();
tmp = element.attribute("scale");
if (!tmp.isEmpty())
m_imageProperties.reflectScale = tmp.toInt();
tmp = element.attribute("length");
if (!tmp.isEmpty())
m_imageProperties.reflectLength = tmp.toInt();
tmp = element.attribute("spacing");
if (!tmp.isEmpty())
m_imageProperties.reflectSpacing = tmp.toInt();
}
else if (element.tagName() == "mask")
{
QString maskfile = getFirstText(element);
MythImage *newMaskImage = GetPainter()->GetFormatImage();
if (newMaskImage->Load(maskfile))
{
float wmult; // Width multipler
float hmult; // Height multipler
GetMythUI()->GetScreenSettings(wmult, hmult);
if (wmult != 1.0f || hmult != 1.0f)
{
int width = newMaskImage->size().width() * wmult;
int height = newMaskImage->size().height() * hmult;
newMaskImage->Resize(QSize(width, height));
}
m_imageProperties.SetMaskImage(newMaskImage);
}
else
m_imageProperties.SetMaskImage(NULL);
newMaskImage->DecrRef();
}
else if (element.tagName() == "grayscale" ||
element.tagName() == "greyscale")
{
m_imageProperties.isGreyscale = parseBool(element);
}
else
{
return MythUIType::ParseElement(filename, element, showWarnings);
}
m_NeedLoad = true;
if (m_Parent && m_Parent->IsDeferredLoading(true))
m_NeedLoad = false;
return true;
}
/**
* \brief Load the image(s), wraps ImageLoader::LoadImage()
*/
bool MythUIImage::Load(bool allowLoadInBackground, bool forceStat)
{
d->m_UpdateLock.lockForRead();
m_Initiator = m_EnableInitiator;
QString bFilename = m_imageProperties.filename;
bFilename.detach();
d->m_UpdateLock.unlock();
QString filename = bFilename;
if (bFilename.isEmpty())
{
Clear();
SetMinArea(MythRect());
SetRedraw();
return false;
}
if (getenv("DISABLETHREADEDMYTHUIIMAGE"))
allowLoadInBackground = false;
// Don't clear the widget before we need to, otherwise it causes
// unsightly flashing. We exclude animations for now since that requires a
// deeper fix
bool isAnimation = (m_HighNum != m_LowNum) || m_animatedImage;
if (isAnimation)
Clear();
QString imagelabel;
int j = 0;
for (int i = m_LowNum; i <= m_HighNum && !m_animatedImage; i++)
{
if (!m_animatedImage && m_HighNum != m_LowNum &&
bFilename.contains("%1"))
filename = bFilename.arg(i);
ImageProperties imProps = m_imageProperties;
imProps.filename = filename;
imagelabel = ImageLoader::GenImageLabel(imProps);
// Only load in the background if allowed and the image is
// not already in our mem cache
int cacheMode = kCacheIgnoreDisk;
if (forceStat)
cacheMode |= (int)kCacheForceStat;
int cacheMode2 = kCacheNormal;
if (forceStat)
cacheMode2 |= (int)kCacheForceStat;
bool do_background_load = false;
if (allowLoadInBackground)
{
MythImage *img = GetMythUI()->LoadCacheImage(
filename, imagelabel, GetPainter(),
static_cast<ImageCacheMode>(cacheMode));
if (img)
img->DecrRef();
else
do_background_load = true;
}
if (do_background_load)
{
SetMinArea(MythRect());
LOG(VB_GUI | VB_FILE, LOG_DEBUG, LOC +
QString("Load(), spawning thread to load '%1'").arg(filename));
m_runningThreads++;
ImageLoadThread *bImgThread;
bImgThread = new ImageLoadThread(this, GetPainter(),
imProps,
bFilename, i,
static_cast<ImageCacheMode>(cacheMode2));
GetMythUI()->GetImageThreadPool()->start(bImgThread, "ImageLoad");
}
else
{
if (!isAnimation && !GetMythUI()->IsImageInCache(imagelabel))
Clear();
// Perform a blocking load
LOG(VB_GUI | VB_FILE, LOG_DEBUG, LOC +
QString("Load(), loading '%1' in foreground").arg(filename));
bool aborted = false;
if (ImageLoader::SupportsAnimation(filename))
{
AnimationFrames *myFrames;
myFrames = ImageLoader::LoadAnimatedImage(GetPainter(), imProps,
static_cast<ImageCacheMode>(cacheMode2),
this, aborted);
// TODO We might want to handle an abort here more gracefully
if (aborted)
LOG(VB_GUI, LOG_DEBUG, QString("Aborted loading animated"
"image %1 in foreground")
.arg(filename));
SetAnimationFrames(*myFrames);
delete myFrames;
}
else
{
MythImage *image = NULL;
image = ImageLoader::LoadImage(GetPainter(),
imProps,
static_cast<ImageCacheMode>(cacheMode2),
this, aborted);
// TODO We might want to handle an abort here more gracefully
if (aborted)
LOG(VB_GUI, LOG_DEBUG, QString("Aborted loading animated"
"image %1 in foreground")
.arg(filename));
if (image)
{
if (m_imageProperties.forceSize.isNull())
SetSize(image->size());
MythRect rect(GetFullArea());
rect.setSize(image->size());
SetMinArea(rect);
m_ImagesLock.lock();
m_Images[j] = image;
m_ImagesLock.unlock();
SetRedraw();
d->m_UpdateLock.lockForWrite();
m_LastDisplay = QTime::currentTime();
d->m_UpdateLock.unlock();
}
else
{
Reset();
m_ImagesLock.lock();
m_Images[j] = NULL;
m_ImagesLock.unlock();
}
}
}
++j;
}
return true;
}
void MythScreenStack::EnableEffects(void)
{
m_DoTransitions = (GetPainter()->SupportsAlpha() &&
GetPainter()->SupportsAnimation());
}
void SurfaceImpl::PenColour(ColourDesired fore)
{
QPen penOutline(QColorFromCA(fore));
penOutline.setCapStyle(Qt::FlatCap);
GetPainter()->setPen(penOutline);
}
void SurfaceImpl::BrushColour(ColourDesired back)
{
GetPainter()->setBrush(QBrush(QColorFromCA(back)));
}
/**
* \brief Load an image
*/
MythImage *MythUIImage::LoadImage(
MythImageReader &imageReader, const QString &imFile,
QSize bForceSize, int cacheMode)
{
QString filename = imFile;
m_loadingImagesLock.lock();
// Check to see if the image is being loaded by us in another thread
if ((m_loadingImages.contains(filename)) &&
(m_loadingImages[filename] == this))
{
VERBOSE(VB_GUI|VB_FILE|VB_EXTRA, LOC + QString(
"MythUIImage::LoadImage(%1), this "
"file is already being loaded by this same MythUIImage in "
"another thread.").arg(filename));
m_loadingImagesLock.unlock();
return NULL;
}
// Check to see if the exact same image is being loaded anywhere else
while (m_loadingImages.contains(filename))
m_loadingImagesCond.wait(&m_loadingImagesLock);
m_loadingImages[filename] = this;
m_loadingImagesLock.unlock();
VERBOSE(VB_GUI|VB_FILE, LOC + QString("LoadImage(%2) Object %3")
.arg(filename).arg(objectName()));
MythImage *image = NULL;
bool bForceResize = false;
bool bFoundInCache = false;
QString imagelabel;
int w = -1;
int h = -1;
if (!bForceSize.isNull())
{
if (bForceSize.width() != -1)
w = bForceSize.width();
if (bForceSize.height() != -1)
h = bForceSize.height();
bForceResize = true;
}
imagelabel = GenImageLabel(filename, w, h);
if (!imageReader.supportsAnimation())
{
image = GetMythUI()->LoadCacheImage(
filename, imagelabel, GetPainter(), (ImageCacheMode) cacheMode);
}
if (image)
{
image->UpRef();
VERBOSE(VB_GUI|VB_FILE, LOC +
QString("LoadImage found in cache :%1: RefCount = %2")
.arg(imagelabel).arg(image->RefCount()));
if (m_isReflected)
image->setIsReflected(true);
bFoundInCache = true;
}
else
{
VERBOSE(VB_GUI|VB_FILE, LOC +
QString("LoadImage Not Found in cache. "
"Loading Directly :%1:").arg(filename));
image = GetPainter()->GetFormatImage();
image->UpRef();
bool ok = false;
if (imageReader.supportsAnimation())
ok = image->Load(imageReader);
else
ok = image->Load(filename);
if (!ok)
{
image->DownRef();
m_loadingImagesLock.lock();
m_loadingImages.remove(filename);
m_loadingImagesCond.wakeAll();
m_loadingImagesLock.unlock();
return NULL;
}
}
if (!bFoundInCache)
{
if (bForceResize)
image->Resize(QSize(w, h), m_preserveAspect);
if (m_isMasked)
{
QRect imageArea = image->rect();
QRect maskArea = m_maskImage->rect();
// 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);
d->m_UpdateLock.lockForWrite();
QImage mask = m_maskImage->copy(imageArea);
d->m_UpdateLock.unlock();
image->setAlphaChannel(mask.alphaChannel());
}
if (m_isReflected)
image->Reflect(m_reflectAxis, m_reflectShear, m_reflectScale,
m_reflectLength, m_reflectSpacing);
if (m_isGreyscale)
image->ToGreyscale();
if (!imageReader.supportsAnimation())
GetMythUI()->CacheImage(imagelabel, image);
}
if (image->isNull())
{
VERBOSE(VB_GUI|VB_FILE, LOC + QString("LoadImage Image is NULL :%1:")
.arg(filename));
image->DownRef();
Reset();
m_loadingImagesLock.lock();
m_loadingImages.remove(filename);
m_loadingImagesCond.wakeAll();
m_loadingImagesLock.unlock();
return NULL;
}
image->SetChanged();
m_loadingImagesLock.lock();
m_loadingImages.remove(filename);
m_loadingImagesCond.wakeAll();
m_loadingImagesLock.unlock();
return image;
}
void SurfaceImpl::FillRectangle(PRectangle rc, ColourDesired back)
{
BrushColour(back);
GetPainter()->setPen(Qt::NoPen);
GetPainter()->drawRect(QRectFromPRect(rc));
}
