void
KVirtualBGRenderer::initRenderers()
{
KConfigGroup cg(m_pConfig, "Background Common");
// Same config for each screen?
// FIXME: Could use same renderer for identically-sized screens.
m_bCommonScreen = cg.readEntry("CommonScreen", _defCommonScreen);
// Do not split one big image over all screens?
m_bDrawBackgroundPerScreen =
cg.readEntry("DrawBackgroundPerScreen_0", _defDrawBackgroundPerScreen);
m_numRenderers = m_bDrawBackgroundPerScreen ? QApplication::desktop()->numScreens() : 1;
m_bFinished.resize(m_numRenderers);
m_bFinished.fill(false);
if (m_numRenderers == m_renderer.size())
return;
qDeleteAll(m_renderer);
m_renderer.resize(m_numRenderers);
for (int i = 0; i < m_numRenderers; i++) {
int eScreen = m_bCommonScreen ? 0 : i;
KBackgroundRenderer *r = new KBackgroundRenderer(eScreen, m_bDrawBackgroundPerScreen, m_pConfig);
m_renderer.insert(i, r);
r->setSize(renderSize(i));
connect(r, SIGNAL(imageDone(int)), SLOT(screenDone(int)));
}
}
void BGDialog::desktopResized()
{
for (int j = 0; j < m_renderer.size(); ++j) {
KBackgroundRenderer *r = m_renderer[j];
if (r->isActive())
r->stop();
r->desktopResized();
}
eRenderer()->start(true);
}
void BGDialog::slotSecondaryColor(const QColor &color)
{
KBackgroundRenderer *r = eRenderer();
if (color == r->colorB())
return;
r->stop();
r->setColorB(color);
r->start(true);
m_copyAllScreens = true;
emit changed(true);
}
void BGDialog::slotSetupMulti()
{
KBackgroundRenderer *r = eRenderer();
BGMultiWallpaperDialog dlg(r, window());
if (dlg.exec() == QDialog::Accepted) {
r->stop();
m_slideShowRandom = r->multiWallpaperMode();
r->setWallpaperMode(m_wallpaperPos);
r->start(true);
m_copyAllScreens = true;
emit changed(true);
}
}
void BGDialog::slotWallpaperPos(int mode)
{
KBackgroundRenderer *r = eRenderer();
mode++;
m_wallpaperPos = mode;
if (mode == r->wallpaperMode())
return;
r->stop();
r->setWallpaperMode(mode);
r->start(true);
m_copyAllScreens = true;
emit changed(true);
}
void
MyApplication::renderDone()
{
desktop()->setBackgroundPixmap( renderer.pixmap() );
desktop()->repaint( true );
renderer.saveCacheFile();
renderer.cleanup();
for (unsigned i=0; i<renderer.numRenderers(); ++i)
{
KBackgroundRenderer * r = renderer.renderer(i);
if (r->backgroundMode() == KBackgroundSettings::Program ||
(r->multiWallpaperMode() != KBackgroundSettings::NoMulti &&
r->multiWallpaperMode() != KBackgroundSettings::NoMultiRandom))
return;
}
quit();
}
void
MyApplication::renderDone()
{
QPalette palette;
palette.setBrush(desktop()->backgroundRole(), QBrush(renderer.pixmap()));
desktop()->setPalette(palette);
XClearWindow(QX11Info::display(), desktop()->winId());
renderer.saveCacheFile();
renderer.cleanup();
for (unsigned i = 0; i < renderer.numRenderers(); ++i) {
KBackgroundRenderer *r = renderer.renderer(i);
if (r->backgroundMode() == KBackgroundSettings::Program ||
(r->multiWallpaperMode() != KBackgroundSettings::NoMulti &&
r->multiWallpaperMode() != KBackgroundSettings::NoMultiRandom))
return;
}
quit();
}
void BGDialog::slotAdvanced()
{
KBackgroundRenderer *r = eRenderer();
m_previewUpdates = false;
BGAdvancedDialog dlg(r, window());
if (!m_pMonitorArrangement->isEnabled()) {
dlg.makeReadOnly();
dlg.exec();
return;
}
#if 0
if (m_pGlobals->limitCache())
dlg.setCacheSize(m_pGlobals->cacheSize());
else
dlg.setCacheSize(0);
#endif
if (!dlg.exec()) {
m_previewUpdates = true;
return;
}
#if 0
int cacheSize = dlg.cacheSize();
if (cacheSize) {
m_pGlobals->setCacheSize(cacheSize);
m_pGlobals->setLimitCache(true);
} else {
m_pGlobals->setLimitCache(false);
}
#endif
r->stop();
m_previewUpdates = true;
r->start(true);
updateUI();
emit changed(true);
}
void BGDialog::slotPreviewDone(int screen_done)
{
if (!m_previewUpdates)
return;
KBackgroundRenderer *r = m_renderer[(m_eScreen>1) ? (screen_done+2) : m_eScreen];
if (r->image().isNull())
return;
r->saveCacheFile();
QPixmap pm = QPixmap::fromImage(r->image());
if (m_eScreen == 0) {
m_pMonitorArrangement->setPixmap(pm);
} else if (m_eScreen == 1) {
for (unsigned i = 0; i < m_pMonitorArrangement->numMonitors(); ++i)
m_pMonitorArrangement->monitor(i)->setPreview(pm);
} else {
m_pMonitorArrangement->monitor(screen_done)->setPreview(pm);
}
}
void BGDialog::slotPattern(int pattern)
{
KBackgroundRenderer *r = eRenderer();
r->stop();
bool bSecondaryEnabled = true;
if (pattern < NR_PREDEF_PATTERNS) {
if (pattern == 0) {
r->setBackgroundMode(KBackgroundSettings::Flat);
bSecondaryEnabled = false;
} else {
r->setBackgroundMode(pattern - 1 + KBackgroundSettings::HorizontalGradient);
}
} else {
r->setBackgroundMode(KBackgroundSettings::Pattern);
r->setPatternName(m_patterns[pattern - NR_PREDEF_PATTERNS]);
}
r->start(true);
m_colorSecondary->setEnabled(bSecondaryEnabled);
m_copyAllScreens = true;
emit changed(true);
}
void BGDialog::slotWallpaperTypeChanged(int i)
{
KBackgroundRenderer *r = eRenderer();
r->stop();
// No picture
if (i == m_buttonGroupBackground->id(m_radioNoPicture)) { //None
m_urlWallpaperBox->setEnabled(false);
m_urlWallpaperButton->setEnabled(false);
m_buttonSetupWallpapers->setEnabled(false);
m_comboWallpaperPos->setEnabled(false);
m_lblWallpaperPos->setEnabled(false);
r->setWallpaperMode(KBackgroundSettings::NoWallpaper);
if (m_slideShowRandom == KBackgroundSettings::InOrder)
r->setMultiWallpaperMode(KBackgroundSettings::NoMulti);
else
r->setMultiWallpaperMode(KBackgroundSettings::NoMultiRandom);
setBlendingEnabled(false);
}
// Slide show
else if (i == m_buttonGroupBackground->id(m_radioSlideShow)) {
m_urlWallpaperBox->setEnabled(false);
m_urlWallpaperButton->setEnabled(false);
m_buttonSetupWallpapers->setEnabled(true);
m_comboWallpaperPos->setEnabled(true);
m_lblWallpaperPos->setEnabled(true);
setBlendingEnabled(true);
m_comboWallpaperPos->blockSignals(true);
m_comboWallpaperPos->setCurrentIndex(m_wallpaperPos - 1);
m_comboWallpaperPos->blockSignals(false);
if (r->wallpaperList().count() == 0)
r->setWallpaperMode(KBackgroundSettings::NoWallpaper);
else
r->setWallpaperMode(m_wallpaperPos);
r->setMultiWallpaperMode(m_slideShowRandom);
setWallpaper(r->wallpaper());
setBlendingEnabled(true);
}
// 1 Picture
else if (i == m_buttonGroupBackground->id(m_radioPicture)) {
m_urlWallpaperBox->setEnabled(true);
m_urlWallpaperButton->setEnabled(true);
m_buttonSetupWallpapers->setEnabled(false);
m_lblWallpaperPos->setEnabled(true);
m_comboWallpaperPos->setEnabled(true);
setBlendingEnabled(true);
if (m_slideShowRandom == KBackgroundSettings::InOrder)
r->setMultiWallpaperMode(KBackgroundSettings::NoMulti);
else
r->setMultiWallpaperMode(KBackgroundSettings::NoMultiRandom);
int j = m_urlWallpaperBox->currentIndex();
QString path;
for (QMap<QString, int>::ConstIterator it = m_wallpaper.constBegin();
it != m_wallpaper.constEnd();
++it) {
if (it.value() == j) {
path = it.key();
break;
}
}
KFileMetaInfo metaInfo(path);
if (metaInfo.isValid() && metaInfo.item("Dimensions").isValid()) {
// If the image is greater than 800x600 default to using scaled mode,
// otherwise default to tiled.
QSize s = metaInfo.item("Dimensions").value().toSize();
if (s.width() >= 800 && s.height() >= 600)
m_wallpaperPos = KBackgroundSettings::Scaled;
else
m_wallpaperPos = KBackgroundSettings::Tiled;
} else if (KMimeType::findByPath(path)->is("image/svg+xml")) {
m_wallpaperPos = KBackgroundSettings::Scaled;
}
r->setWallpaperMode(m_wallpaperPos);
m_comboWallpaperPos->blockSignals(true);
m_comboWallpaperPos->setCurrentIndex(m_wallpaperPos - 1);
m_comboWallpaperPos->blockSignals(false);
r->setWallpaper(path);
}
r->start(true);
m_copyAllScreens = true;
emit changed(true);
}
void BGDialog::updateUI()
{
KBackgroundRenderer *r = eRenderer();
m_comboScreen->setCurrentIndex(m_eScreen);
m_colorPrimary->setColor(r->colorA());
m_colorSecondary->setColor(r->colorB());
int wallpaperMode = r->wallpaperMode();
int multiMode = r->multiWallpaperMode();
if (r->backgroundMode() == KBackgroundSettings::Program &&
wallpaperMode == KBackgroundSettings::NoWallpaper)
groupBox3->setEnabled(false);
else
groupBox3->setEnabled(true);
if ((multiMode == KBackgroundSettings::NoMultiRandom) ||
(multiMode == KBackgroundSettings::NoMulti)) {
// No wallpaper
if (wallpaperMode == KBackgroundSettings::NoWallpaper) {
if (!m_readOnly) {
m_urlWallpaperBox->setEnabled(false);
m_urlWallpaperButton->setEnabled(false);
m_buttonSetupWallpapers->setEnabled(false);
m_comboWallpaperPos->setEnabled(false);
m_lblWallpaperPos->setEnabled(false);
}
m_buttonGroupBackground->setSelected(
m_buttonGroupBackground->id(m_radioNoPicture));
}
// 1 Picture
else {
if (!m_readOnly) {
m_urlWallpaperBox->setEnabled(true);
m_urlWallpaperButton->setEnabled(true);
m_buttonSetupWallpapers->setEnabled(false);
m_comboWallpaperPos->setEnabled(true);
m_lblWallpaperPos->setEnabled(true);
}
setWallpaper(r->wallpaper());
m_buttonGroupBackground->setSelected(
m_buttonGroupBackground->id(m_radioPicture));
}
}
// Slide show
else {
if (!m_readOnly) {
m_urlWallpaperBox->setEnabled(false);
m_urlWallpaperButton->setEnabled(false);
m_buttonSetupWallpapers->setEnabled(true);
m_comboWallpaperPos->setEnabled(true);
m_lblWallpaperPos->setEnabled(true);
}
m_buttonGroupBackground->setSelected(
m_buttonGroupBackground->id(m_radioSlideShow));
}
m_comboWallpaperPos->setCurrentIndex(r->wallpaperMode() - 1);
bool bSecondaryEnabled = true;
m_comboPattern->blockSignals(true);
switch (r->backgroundMode()) {
case KBackgroundSettings::Flat:
m_comboPattern->setCurrentIndex(0);
bSecondaryEnabled = false;
break;
case KBackgroundSettings::Pattern: {
int i = m_patterns.indexOf(r->KBackgroundPattern::name());
if (i >= 0)
m_comboPattern->setCurrentIndex(NR_PREDEF_PATTERNS + i);
else
m_comboPattern->setCurrentIndex(0);
}
break;
case KBackgroundSettings::Program:
m_comboPattern->setCurrentIndex(0);
bSecondaryEnabled = false;
break;
default: // Gradient
m_comboPattern->setCurrentIndex(
1 + r->backgroundMode() - KBackgroundSettings::HorizontalGradient);
break;
}
m_comboPattern->blockSignals(false);
m_colorSecondary->setEnabled(bSecondaryEnabled && !m_readOnly);
int mode = r->blendMode();
m_comboBlend->blockSignals(true);
m_sliderBlend->blockSignals(true);
m_comboBlend->setCurrentIndex(mode);
m_cbBlendReverse->setChecked(r->reverseBlending());
m_sliderBlend->setValue(r->blendBalance() / 10);
m_comboBlend->blockSignals(false);
m_sliderBlend->blockSignals(false);
// turn it off if there is no background picture set!
setBlendingEnabled(wallpaperMode != KBackgroundSettings::NoWallpaper);
// Start preview renderer(s)
if (m_eScreen == 0) {
r->setPreview(m_pMonitorArrangement->combinedPreviewSize());
r->start(true);
} else if (m_eScreen == 1) {
r->setPreview(m_pMonitorArrangement->maxPreviewSize());
r->start(true);
} else {
for (unsigned j = 0; j < m_numScreens; ++j) {
m_renderer[j+2]->stop();
m_renderer[j+2]->setPreview(m_pMonitorArrangement->monitor(j)->previewRect().size());
m_renderer[j+2]->start(true);
}
}
}
void BGDialog::defaults()
{
m_pGlobals->setCommonScreenBackground(_defCommonScreen);
m_pGlobals->setLimitCache(_defLimitCache);
m_pGlobals->setCacheSize(_defCacheSize);
m_comboWallpaperPos->setCurrentIndex(0);
getEScreen();
m_pGlobals->setDrawBackgroundPerScreen(false);
KBackgroundRenderer *r = eRenderer();
if (r->isActive())
r->stop();
if (QPixmap::defaultDepth() > 8)
r->setBackgroundMode(_defBackgroundMode);
else
r->setBackgroundMode(KBackgroundSettings::Flat);
r->setColorA(_defColorA);
r->setColorB(_defColorB);
r->setWallpaperMode(_defWallpaperMode);
r->setMultiWallpaperMode(_defMultiMode);
m_slideShowRandom = _defMultiMode;
if (m_slideShowRandom == KBackgroundSettings::NoMultiRandom)
m_slideShowRandom = KBackgroundSettings::Random;
if (m_slideShowRandom == KBackgroundSettings::NoMulti)
m_slideShowRandom = KBackgroundSettings::InOrder;
r->setBlendMode(_defBlendMode);
r->setBlendBalance(_defBlendBalance);
r->setReverseBlending(_defReverseBlending);
updateUI();
m_copyAllScreens = true;
emit changed(true);
}
