//____________________________________________________________________
Configuration Factory::configuration( const Client& client )
{
QString window_title;
QString class_name;
for( ExceptionList::const_iterator iter = _exceptions.constBegin(); iter != _exceptions.constEnd(); ++iter )
{
// discard disabled exceptions
if( !iter->enabled() ) continue;
/*
decide which value is to be compared
to the regular expression, based on exception type
*/
QString value;
switch( iter->type() )
{
case Exception::WindowTitle:
{
value = window_title.isEmpty() ? (window_title = client.caption()):window_title;
break;
}
case Exception::WindowClassName:
{
if( class_name.isEmpty() )
{
// retrieve class name
KWindowInfo info( client.windowId(), 0, NET::WM2WindowClass );
QString window_class_name( info.windowClassName() );
QString window_class( info.windowClassClass() );
class_name = window_class_name + ' ' + window_class;
}
value = class_name;
break;
}
default: assert( false );
}
if( iter->regExp().indexIn( value ) < 0 ) continue;
Configuration configuration( defaultConfiguration() );
configuration.readException( *iter );
configuration.setTransparencyEnabled( iter->transparencyEnabled() );
return configuration;
}
return defaultConfiguration();
}
void KisSimpleNoiseReducer::processImpl(KisPaintDeviceSP device,
const QRect& applyRect,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater
) const
{
QPoint srcTopLeft = applyRect.topLeft();
Q_ASSERT(device);
int threshold, windowsize;
if (config == 0) {
config = defaultConfiguration(device);
}
if (progressUpdater) {
progressUpdater->setRange(0, applyRect.width() * applyRect.height());
}
int count = 0;
threshold = config->getInt("threshold", 15);
windowsize = config->getInt("windowsize", 1);
const KoColorSpace* cs = device->colorSpace();
// Compute the blur mask
KisCircleMaskGenerator* kas = new KisCircleMaskGenerator(2*windowsize + 1, 1, windowsize, windowsize, 2);
KisConvolutionKernelSP kernel = KisConvolutionKernel::fromMaskGenerator(kas);
delete kas;
KisPaintDeviceSP interm = new KisPaintDevice(*device); // TODO no need for a full copy and then a transaction
KisConvolutionPainter painter(interm);
painter.beginTransaction("bouuh");
painter.applyMatrix(kernel, interm, srcTopLeft, srcTopLeft, applyRect.size(), BORDER_REPEAT);
painter.deleteTransaction();
if (progressUpdater && progressUpdater->interrupted()) {
return;
}
KisHLineIteratorSP dstIt = device->createHLineIteratorNG(srcTopLeft.x(), srcTopLeft.y(), applyRect.width());
KisHLineConstIteratorSP intermIt = interm->createHLineConstIteratorNG(srcTopLeft.x(), srcTopLeft.y(), applyRect.width());
for (int j = 0; j < applyRect.height() && !(progressUpdater && progressUpdater->interrupted()); j++) {
do {
quint8 diff = cs->difference(dstIt->oldRawData(), intermIt->oldRawData());
if (diff > threshold) {
memcpy(dstIt->rawData(), intermIt->oldRawData(), cs->pixelSize());
}
if (progressUpdater) progressUpdater->setValue(++count);
intermIt->nextPixel();
} while (dstIt->nextPixel() && !(progressUpdater && progressUpdater->interrupted()));
dstIt->nextRow();
intermIt->nextRow();
}
}
//_________________________________________________________________
bool Factory::supports( Ability ability ) const
{
switch( ability )
{
// announce
case AbilityAnnounceButtons:
case AbilityAnnounceColors:
// buttons
case AbilityButtonMenu:
case AbilityButtonApplicationMenu:
case AbilityButtonHelp:
case AbilityButtonMinimize:
case AbilityButtonMaximize:
case AbilityButtonClose:
case AbilityButtonOnAllDesktops:
case AbilityButtonAboveOthers:
case AbilityButtonBelowOthers:
case AbilityButtonSpacer:
case AbilityButtonShade:
// // colors
// case AbilityColorTitleBack:
// case AbilityColorTitleFore:
// case AbilityColorFrame:
// compositing
case AbilityProvidesShadow: // TODO: UI option to use default shadows instead
return true;
case AbilityUsesAlphaChannel:
case AbilityAnnounceAlphaChannel:
return true;
// tabs
case AbilityTabbing:
return true;
#if KDE_IS_VERSION( 4, 5, 76 )
case AbilityUsesBlurBehind:
return defaultConfiguration().backgroundOpacity() < 255;
#endif
// no colors supported at this time
default:
return false;
};
}
//___________________________________________________
bool Factory::readConfig()
{
bool changed( false );
/*
always reload helper
this is needed to properly handle
color contrast settings changed
*/
helper().invalidateCaches();
helper().reloadConfig();
// create a config object
KConfig config("oxygenrc");
KConfigGroup group( config.group("Windeco") );
Configuration configuration( group );
if( configuration.opacityFromStyle() )
{ configuration.readBackgroundOpacity( config.group("Common") ); }
if( !( configuration == defaultConfiguration() ) )
{
setDefaultConfiguration( configuration );
changed = true;
}
// read exceptionsreadConfig
ExceptionList exceptions( config );
if( !( exceptions == _exceptions ) )
{
_exceptions = exceptions;
changed = true;
}
// read shadowCache configuration
changed |= shadowCache().readConfig( config );
// background pixmap
{
KConfigGroup group( config.group("Common") );
helper().setBackgroundPixmap( group.readEntry( "BackgroundPixmap", "" ) );
}
return changed;
}
void KisWaveletNoiseReduction::process(KisPaintDeviceSP device,
const QRect& applyRect,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater
) const
{
Q_ASSERT(device);
// TODO take selections into account
float threshold;
if (!config) {
config = defaultConfiguration(device);
}
threshold = config->getDouble("threshold", BEST_WAVELET_THRESHOLD_VALUE);
qint32 depth = device->colorSpace()->colorChannelCount();
int size;
int maxrectsize = qMax(applyRect.width(), applyRect.height());
for (size = 2; size < maxrectsize; size *= 2) ;
KisMathToolbox* mathToolbox = KisMathToolboxRegistry::instance()->get(device->colorSpace()->mathToolboxId().id());
if (progressUpdater) {
progressUpdater->setRange(0, mathToolbox->fastWaveletTotalSteps(applyRect) * 2 + size*size*depth);
}
int count = 0;
// connect(mathToolbox, SIGNAL(nextStep()), this, SLOT(incProgress()));
// dbgFilters << size <<"" << maxrectsize <<"" << srcTopLeft.x() <<"" << srcTopLeft.y();
// dbgFilters <<"Transforming...";
// setProgressStage( i18n("Fast wavelet transformation") ,progress());
KisMathToolbox::KisWavelet* buff = 0;
KisMathToolbox::KisWavelet* wav = 0;
try {
buff = mathToolbox->initWavelet(device, applyRect);
} catch (std::bad_alloc) {
if (buff) delete buff;
return;
}
try {
wav = mathToolbox->fastWaveletTransformation(device, applyRect, buff);
} catch (std::bad_alloc) {
if (wav) delete wav;
return;
}
// dbgFilters <<"Thresholding...";
float* fin = wav->coeffs + wav->depth * wav->size * wav->size;
for (float* it = wav->coeffs + wav->depth; it < fin; it++) {
if (*it > threshold) {
*it -= threshold;
} else if (*it < -threshold) {
*it += threshold;
} else {
*it = 0.;
}
if (progressUpdater) progressUpdater->setValue(++count);
}
// dbgFilters <<"Untransforming...";
mathToolbox->fastWaveletUntransformation(device, applyRect, wav, buff);
delete wav;
delete buff;
// disconnect(mathToolbox, SIGNAL(nextStep()), this, SLOT(incProgress()));
}
