TDE
/
tdebase
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdebase
0
0
Fork 0
Code Issues Releases Wiki Activity

Fix standard logout fade when compositing is disabled

Browse Source
pull/2/head
Timothy Pearson 11 years ago
parent 6a40ac081b
commit 3a84ecae5d
1 changed files with 356 additions and 359 deletions
Show Stats Download Patch File Download Diff File

641
ksmserver/shutdowndlg.cpp
Unescape View File

@ -113,402 +113,399 @@ void KSMShutdownFeedback::fadeBack( void )
void KSMShutdownFeedback::slotPaintEffect() void KSMShutdownFeedback::slotPaintEffect()
{ {
// determine which fade to use // determine which fade to use
if (TDEConfigGroup(TDEGlobal::config(), "Logout").readBoolEntry("doFancyLogout", true)) if (TDEConfigGroup(TDEGlobal::config(), "Logout").readBoolEntry("doFancyLogout", true)) {
{ // fancy logout fade
float doFancyLogoutAdditionalDarkness = (float)TDEConfigGroup(TDEGlobal::config(), "Logout").readDoubleNumEntry("doFancyLogoutAdditionalDarkness", 0.6);
float doFancyLogoutAdditionalDarkness = (float)TDEConfigGroup(TDEGlobal::config(), "Logout").readDoubleNumEntry("doFancyLogoutAdditionalDarkness", 0.6); float doFancyLogoutFadeTime = (float)TDEConfigGroup(TDEGlobal::config(), "Logout").readDoubleNumEntry("doFancyLogoutFadeTime", 4000);
float doFancyLogoutFadeBackTime = (float)TDEConfigGroup(TDEGlobal::config(), "Logout").readDoubleNumEntry("doFancyLogoutFadeBackTime", 1000);
float doFancyLogoutFadeTime = (float)TDEConfigGroup(TDEGlobal::config(), "Logout").readDoubleNumEntry("doFancyLogoutFadeTime", 4000);
if (kapp->isX11CompositionAvailable()) {
float doFancyLogoutFadeBackTime = (float)TDEConfigGroup(TDEGlobal::config(), "Logout").readDoubleNumEntry("doFancyLogoutFadeBackTime", 1000); // We can do this in a different (simpler) manner because we have compositing support!
// if slotPaintEffect() is called first time, we have to initialize the gray image
// we also could do that in the constructor, but then the displaying of the
// logout-UI would be too much delayed...
if ( m_greyImageCreated == false )
{
m_greyImageCreated = true;
if (kapp->isX11CompositionAvailable()) { // eliminate nasty flicker on first show
// We can do this in a different (simpler) manner because we have compositing support! m_root.resize( width(), height() );
// if slotPaintEffect() is called first time, we have to initialize the gray image TQImage blendedImage = m_grayImage;
// we also could do that in the constructor, but then the displaying of the TQPainter p;
// logout-UI would be too much delayed... p.begin( &m_root );
if ( m_greyImageCreated == false ) blendedImage.setAlphaBuffer(false);
{ p.drawImage( 0, 0, blendedImage );
m_greyImageCreated = true; p.end();
// eliminate nasty flicker on first show setBackgroundPixmap( m_root );
m_root.resize( width(), height() ); setGeometry( TQApplication::desktop()->geometry() );
TQImage blendedImage = m_grayImage; setBackgroundMode( TQWidget::NoBackground );
TQPainter p;
p.begin( &m_root );
blendedImage.setAlphaBuffer(false);
p.drawImage( 0, 0, blendedImage );
p.end();
setBackgroundPixmap( m_root ); m_unfadedImage = m_grayImage.copy();
setGeometry( TQApplication::desktop()->geometry() );
setBackgroundMode( TQWidget::NoBackground );
m_unfadedImage = m_grayImage.copy(); register uchar * r = m_grayImage.bits();
uchar * end = m_grayImage.bits() + m_grayImage.numBytes();
register uchar * r = m_grayImage.bits(); while ( r != end ) {
uchar * end = m_grayImage.bits() + m_grayImage.numBytes(); *reinterpret_cast<TQRgb*>(r) = tqRgba(0, 0, 0, 128);
r += 4;
}
while ( r != end ) { // start timer which is used for cpu-speed-independent fading
*reinterpret_cast<TQRgb*>(r) = tqRgba(0, 0, 0, 128); m_fadeTime.start();
r += 4; m_rowsDone = 0;
} }
// start timer which is used for cpu-speed-independent fading // return if fading is completely done...
m_fadeTime.start(); if ( ( m_grayOpacity >= 1.0f && m_fadeBackwards == FALSE ) || ( m_grayOpacity <= 0.0f && m_fadeBackwards == TRUE ) )
m_rowsDone = 0; return;
}
// return if fading is completely done...
if ( ( m_grayOpacity >= 1.0f && m_fadeBackwards == FALSE ) || ( m_grayOpacity <= 0.0f && m_fadeBackwards == TRUE ) )
return;
if ( m_fadeBackwards == FALSE ) if ( m_fadeBackwards == FALSE )
{ {
m_grayOpacity = m_fadeTime.elapsed() / doFancyLogoutFadeTime; m_grayOpacity = m_fadeTime.elapsed() / doFancyLogoutFadeTime;
if ( m_grayOpacity > 1.0f ) if ( m_grayOpacity > 1.0f )
m_grayOpacity = 1.0f; m_grayOpacity = 1.0f;
} }
else else
{ {
m_grayOpacity = 1.0f - m_fadeTime.elapsed() / doFancyLogoutFadeBackTime - m_compensation; m_grayOpacity = 1.0f - m_fadeTime.elapsed() / doFancyLogoutFadeBackTime - m_compensation;
if ( m_grayOpacity < 0.0f ) if ( m_grayOpacity < 0.0f )
m_grayOpacity = 0.0f; m_grayOpacity = 0.0f;
} }
const int imgWidth = m_unfadedImage.width(); const int imgWidth = m_unfadedImage.width();
int imgHeight = m_unfadedImage.height(); int imgHeight = m_unfadedImage.height();
int heightUnit = imgHeight / 3; int heightUnit = imgHeight / 3;
if( heightUnit < 1 ) if( heightUnit < 1 )
heightUnit = 1; heightUnit = 1;
int y1 = static_cast<int>( imgHeight*m_grayOpacity - heightUnit + m_grayOpacity*heightUnit*2.0f ); int y1 = static_cast<int>( imgHeight*m_grayOpacity - heightUnit + m_grayOpacity*heightUnit*2.0f );
if( y1 > imgHeight ) if( y1 > imgHeight )
y1 = imgHeight; y1 = imgHeight;
int y2 = y1+heightUnit; int y2 = y1+heightUnit;
if( y2 > imgHeight ) if( y2 > imgHeight )
y2 = imgHeight; y2 = imgHeight;
if( m_fadeBackwards == FALSE ) if( m_fadeBackwards == FALSE )
{
if( y1 > 0 && y1 < imgHeight && y1-m_rowsDone > 0 && m_rowsDone < imgHeight )
{ {
TQImage img( imgWidth, y1-m_rowsDone, 32 ); if( y1 > 0 && y1 < imgHeight && y1-m_rowsDone > 0 && m_rowsDone < imgHeight )
memcpy( img.bits(), m_grayImage.scanLine( m_rowsDone ), imgWidth*(y1-m_rowsDone)*4 ); {
bitBlt( this, 0, m_rowsDone, &img ); TQImage img( imgWidth, y1-m_rowsDone, 32 );
m_rowsDone = y1; memcpy( img.bits(), m_grayImage.scanLine( m_rowsDone ), imgWidth*(y1-m_rowsDone)*4 );
bitBlt( this, 0, m_rowsDone, &img );
m_rowsDone = y1;
}
} }
} else
else
{
// when fading back we have to blit area which isnt gray anymore to unfaded image
if( y2 > 0 && y2 < imgHeight && m_rowsDone > y2 )
{ {
TQImage img( imgWidth, m_rowsDone-y2, 32 ); // when fading back we have to blit area which isnt gray anymore to unfaded image
memcpy( img.bits(), m_unfadedImage.scanLine( y2 ), imgWidth*(m_rowsDone-y2)*4 ); if( y2 > 0 && y2 < imgHeight && m_rowsDone > y2 )
bitBlt( this, 0, y2, &img ); {
m_rowsDone = y2; TQImage img( imgWidth, m_rowsDone-y2, 32 );
memcpy( img.bits(), m_unfadedImage.scanLine( y2 ), imgWidth*(m_rowsDone-y2)*4 );
bitBlt( this, 0, y2, &img );
m_rowsDone = y2;
}
} }
}
int start_y1 = y1; int start_y1 = y1;
if( start_y1 < 0 ) if( start_y1 < 0 )
start_y1 = 0; start_y1 = 0;
if( y2 > start_y1 ) if( y2 > start_y1 )
{
TQImage img( imgWidth, y2-start_y1, 32 );
memcpy( img.bits(), m_grayImage.scanLine( start_y1 ), ( y2-start_y1 ) * imgWidth * 4 );
register uchar * rs = m_unfadedImage.scanLine( start_y1 );
register uchar * rd = img.bits();
for( int y = start_y1; y < y2; ++y )
{ {
// linear gradients look bad, so use cos-function TQImage img( imgWidth, y2-start_y1, 32 );
short int opac = static_cast<short int>( 128 - cosf( M_PI*(y-y1)/heightUnit )*128.0f ); memcpy( img.bits(), m_grayImage.scanLine( start_y1 ), ( y2-start_y1 ) * imgWidth * 4 );
for( short int x = 0; x < imgWidth; ++x ) register uchar * rs = m_unfadedImage.scanLine( start_y1 );
register uchar * rd = img.bits();
for( int y = start_y1; y < y2; ++y )
{ {
*reinterpret_cast<TQRgb*>(rd) = tqRgba(0, 0, 0, ((255.0-opac)/(255.0/127.0))); // linear gradients look bad, so use cos-function
rs += 4; rd += 4; short int opac = static_cast<short int>( 128 - cosf( M_PI*(y-y1)/heightUnit )*128.0f );
for( short int x = 0; x < imgWidth; ++x )
{
*reinterpret_cast<TQRgb*>(rd) = tqRgba(0, 0, 0, ((255.0-opac)/(255.0/127.0)));
rs += 4; rd += 4;
}
} }
bitBlt( this, 0, start_y1, &img );
} }
bitBlt( this, 0, start_y1, &img );
TQTimer::singleShot( 5, this, TQT_SLOT( slotPaintEffect() ) );
} }
else {
// if slotPaintEffect() is called first time, we have to initialize the gray image
// we also could do that in the constructor, but then the displaying of the
// logout-UI would be too much delayed...
if ( m_greyImageCreated == false )
{
m_greyImageCreated = true;
TQTimer::singleShot( 5, this, TQT_SLOT( slotPaintEffect() ) ); setBackgroundMode( TQWidget::NoBackground );
} setGeometry( TQApplication::desktop()->geometry() );
else { m_root.resize( width(), height() ); // for the default logout
// if slotPaintEffect() is called first time, we have to initialize the gray image
// we also could do that in the constructor, but then the displaying of the
// logout-UI would be too much delayed...
if ( m_greyImageCreated == false )
{
m_greyImageCreated = true;
setBackgroundMode( TQWidget::NoBackground ); m_unfadedImage = m_grayImage.copy();
setGeometry( TQApplication::desktop()->geometry() );
m_root.resize( width(), height() ); // for the default logout
m_unfadedImage = m_grayImage.copy(); register uchar * r = m_grayImage.bits();
register uchar * g = m_grayImage.bits() + 1;
register uchar * b = m_grayImage.bits() + 2;
uchar * end = m_grayImage.bits() + m_grayImage.numBytes();
register uchar * r = m_grayImage.bits(); while ( r != end ) {
register uchar * g = m_grayImage.bits() + 1; *r = *g = *b = (uchar) ( ( (*r)*11 + ((*g)<<4) + (*b)*5 ) * doFancyLogoutAdditionalDarkness / 32.0f );
register uchar * b = m_grayImage.bits() + 2; r += 4;
uchar * end = m_grayImage.bits() + m_grayImage.numBytes(); g += 4;
b += 4;
}
while ( r != end ) { // start timer which is used for cpu-speed-independent fading
*r = *g = *b = (uchar) ( ( (*r)*11 + ((*g)<<4) + (*b)*5 ) * doFancyLogoutAdditionalDarkness / 32.0f ); m_fadeTime.start();
r += 4; m_rowsDone = 0;
g += 4;
b += 4;
} }
// start timer which is used for cpu-speed-independent fading // return if fading is completely done...
m_fadeTime.start(); if ( ( m_grayOpacity >= 1.0f && m_fadeBackwards == FALSE ) || ( m_grayOpacity <= 0.0f && m_fadeBackwards == TRUE ) )
m_rowsDone = 0; return;
}
// return if fading is completely done...
if ( ( m_grayOpacity >= 1.0f && m_fadeBackwards == FALSE ) || ( m_grayOpacity <= 0.0f && m_fadeBackwards == TRUE ) )
return;
if ( m_fadeBackwards == FALSE ) if ( m_fadeBackwards == FALSE )
{ {
m_grayOpacity = m_fadeTime.elapsed() / doFancyLogoutFadeTime; m_grayOpacity = m_fadeTime.elapsed() / doFancyLogoutFadeTime;
if ( m_grayOpacity > 1.0f ) if ( m_grayOpacity > 1.0f )
m_grayOpacity = 1.0f; m_grayOpacity = 1.0f;
} }
else else
{ {
m_grayOpacity = 1.0f - m_fadeTime.elapsed() / doFancyLogoutFadeBackTime - m_compensation; m_grayOpacity = 1.0f - m_fadeTime.elapsed() / doFancyLogoutFadeBackTime - m_compensation;
if ( m_grayOpacity < 0.0f ) if ( m_grayOpacity < 0.0f )
m_grayOpacity = 0.0f; m_grayOpacity = 0.0f;
} }
const int imgWidth = m_unfadedImage.width(); const int imgWidth = m_unfadedImage.width();
int imgHeight = m_unfadedImage.height(); int imgHeight = m_unfadedImage.height();
int heightUnit = imgHeight / 3; int heightUnit = imgHeight / 3;
if( heightUnit < 1 ) if( heightUnit < 1 )
heightUnit = 1; heightUnit = 1;
int y1 = static_cast<int>( imgHeight*m_grayOpacity - heightUnit + m_grayOpacity*heightUnit*2.0f ); int y1 = static_cast<int>( imgHeight*m_grayOpacity - heightUnit + m_grayOpacity*heightUnit*2.0f );
if( y1 > imgHeight ) if( y1 > imgHeight )
y1 = imgHeight; y1 = imgHeight;
int y2 = y1+heightUnit; int y2 = y1+heightUnit;
if( y2 > imgHeight ) if( y2 > imgHeight )
y2 = imgHeight; y2 = imgHeight;
if( m_fadeBackwards == FALSE ) if( m_fadeBackwards == FALSE )
{
if( y1 > 0 && y1 < imgHeight && y1-m_rowsDone > 0 && m_rowsDone < imgHeight )
{ {
TQImage img( imgWidth, y1-m_rowsDone, 32 ); if( y1 > 0 && y1 < imgHeight && y1-m_rowsDone > 0 && m_rowsDone < imgHeight )
memcpy( img.bits(), m_grayImage.scanLine( m_rowsDone ), imgWidth*(y1-m_rowsDone)*4 ); {
// conversion is slow as hell if desktop-depth != 24bpp... TQImage img( imgWidth, y1-m_rowsDone, 32 );
//Pixmap pm = m_pmio.convertToPixmap( img ); memcpy( img.bits(), m_grayImage.scanLine( m_rowsDone ), imgWidth*(y1-m_rowsDone)*4 );
//bitBlt( this, 0, m_rowsDone, &pm ); // conversion is slow as hell if desktop-depth != 24bpp...
//TQImage pm = m_pmio.convertToImage( img ); //Pixmap pm = m_pmio.convertToPixmap( img );
bitBlt( this, 0, m_rowsDone, &img ); //bitBlt( this, 0, m_rowsDone, &pm );
m_rowsDone = y1; //TQImage pm = m_pmio.convertToImage( img );
bitBlt( this, 0, m_rowsDone, &img );
m_rowsDone = y1;
}
} }
} else
else
{
// when fading back we have to blit area which isnt gray anymore to unfaded image
if( y2 > 0 && y2 < imgHeight && m_rowsDone > y2 )
{ {
TQImage img( imgWidth, m_rowsDone-y2, 32 ); // when fading back we have to blit area which isnt gray anymore to unfaded image
memcpy( img.bits(), m_unfadedImage.scanLine( y2 ), imgWidth*(m_rowsDone-y2)*4 ); if( y2 > 0 && y2 < imgHeight && m_rowsDone > y2 )
// conversion is slow as hell if desktop-depth != 24bpp... {
//TQPixmap pm = m_pmio.convertToPixmap( img ); TQImage img( imgWidth, m_rowsDone-y2, 32 );
//bitBlt( this, 0, y2, &pm ); memcpy( img.bits(), m_unfadedImage.scanLine( y2 ), imgWidth*(m_rowsDone-y2)*4 );
bitBlt( this, 0, y2, &img ); // conversion is slow as hell if desktop-depth != 24bpp...
m_rowsDone = y2; //TQPixmap pm = m_pmio.convertToPixmap( img );
//bitBlt( this, 0, y2, &pm );
bitBlt( this, 0, y2, &img );
m_rowsDone = y2;
}
} }
}
int start_y1 = y1; int start_y1 = y1;
if( start_y1 < 0 ) if( start_y1 < 0 )
start_y1 = 0; start_y1 = 0;
if( y2 > start_y1 ) if( y2 > start_y1 )
{
TQImage img( imgWidth, y2-start_y1, 32 );
memcpy( img.bits(), m_grayImage.scanLine( start_y1 ), ( y2-start_y1 ) * imgWidth * 4 );
register uchar * rs = m_unfadedImage.scanLine( start_y1 );
register uchar * gs = rs + 1;
register uchar * bs = gs + 1;
register uchar * rd = img.bits();
register uchar * gd = rd + 1;
register uchar * bd = gd + 1;
for( int y = start_y1; y < y2; ++y )
{ {
// linear gradients look bad, so use cos-function TQImage img( imgWidth, y2-start_y1, 32 );
short int opac = static_cast<short int>( 128 - cosf( M_PI*(y-y1)/heightUnit )*128.0f ); memcpy( img.bits(), m_grayImage.scanLine( start_y1 ), ( y2-start_y1 ) * imgWidth * 4 );
for( short int x = 0; x < imgWidth; ++x ) register uchar * rs = m_unfadedImage.scanLine( start_y1 );
register uchar * gs = rs + 1;
register uchar * bs = gs + 1;
register uchar * rd = img.bits();
register uchar * gd = rd + 1;
register uchar * bd = gd + 1;
for( int y = start_y1; y < y2; ++y )
{ {
*rd += ( ( ( *rs - *rd ) * opac ) >> 8 ); // linear gradients look bad, so use cos-function
rs += 4; rd += 4; short int opac = static_cast<short int>( 128 - cosf( M_PI*(y-y1)/heightUnit )*128.0f );
*gd += ( ( ( *gs - *gd ) * opac ) >> 8 ); for( short int x = 0; x < imgWidth; ++x )
gs += 4; gd += 4; {
*bd += ( ( ( *bs - *bd ) * opac ) >> 8 ); *rd += ( ( ( *rs - *rd ) * opac ) >> 8 );
bs += 4; bd += 4; rs += 4; rd += 4;
*gd += ( ( ( *gs - *gd ) * opac ) >> 8 );
gs += 4; gd += 4;
*bd += ( ( ( *bs - *bd ) * opac ) >> 8 );
bs += 4; bd += 4;
}
} }
// conversion is slow as hell if desktop-depth != 24bpp...
//TQPixmap pm = m_pmio.convertToPixmap( img );
//bitBlt( this, 0, start_y1, &pm );
bitBlt( this, 0, start_y1, &img );
} }
// conversion is slow as hell if desktop-depth != 24bpp...
//TQPixmap pm = m_pmio.convertToPixmap( img );
//bitBlt( this, 0, start_y1, &pm );
bitBlt( this, 0, start_y1, &img );
}
TQTimer::singleShot( 5, this, TQT_SLOT( slotPaintEffect() ) );
}
TQTimer::singleShot( 5, this, TQT_SLOT( slotPaintEffect() ) );
}
} }
// standard logout fade else {
else // standard logout fade
{
if (kapp->isX11CompositionAvailable()) { if (kapp->isX11CompositionAvailable()) {
// We can do this in a different (simpler) manner because we have compositing support! // We can do this in a different (simpler) manner because we have compositing support!
// The end effect will be very similar to the old style logout // The end effect will be very similar to the old style logout
float doFancyLogoutFadeTime = 1000; float doFancyLogoutFadeTime = 1000;
float doFancyLogoutFadeBackTime = 0; float doFancyLogoutFadeBackTime = 0;
if ( m_greyImageCreated == false ) if ( m_greyImageCreated == false ) {
{ m_greyImageCreated = true;
m_greyImageCreated = true;
// eliminate nasty flicker on first show
m_root.resize( width(), height() );
TQImage blendedImage = m_grayImage;
TQPainter p;
p.begin( &m_root );
blendedImage.setAlphaBuffer(false);
p.drawImage( 0, 0, blendedImage );
p.end();
// eliminate nasty flicker on first show setBackgroundPixmap( m_root );
m_root.resize( width(), height() ); setGeometry( TQApplication::desktop()->geometry() );
TQImage blendedImage = m_grayImage; setBackgroundMode( TQWidget::NoBackground );
TQPainter p;
p.begin( &m_root );
blendedImage.setAlphaBuffer(false);
p.drawImage( 0, 0, blendedImage );
p.end();
setBackgroundPixmap( m_root ); m_unfadedImage = m_grayImage.copy();
setGeometry( TQApplication::desktop()->geometry() );
setBackgroundMode( TQWidget::NoBackground );
m_unfadedImage = m_grayImage.copy(); register uchar * r = m_grayImage.bits();
uchar * end = m_grayImage.bits() + m_grayImage.numBytes();
register uchar * r = m_grayImage.bits(); while ( r != end ) {
uchar * end = m_grayImage.bits() + m_grayImage.numBytes(); *reinterpret_cast<TQRgb*>(r) = tqRgba(0, 0, 0, 107);
r += 4;
}
while ( r != end ) { // start timer which is used for cpu-speed-independent fading
*reinterpret_cast<TQRgb*>(r) = tqRgba(0, 0, 0, 107); m_fadeTime.start();
r += 4; m_rowsDone = 0;
} }
// start timer which is used for cpu-speed-independent fading // return if fading is completely done...
m_fadeTime.start(); if ( ( m_grayOpacity >= 1.0f && m_fadeBackwards == FALSE ) || ( m_grayOpacity <= 0.0f && m_fadeBackwards == TRUE ) ) {
m_rowsDone = 0; return;
} }
// return if fading is completely done...
if ( ( m_grayOpacity >= 1.0f && m_fadeBackwards == FALSE ) || ( m_grayOpacity <= 0.0f && m_fadeBackwards == TRUE ) )
return;
if ( m_fadeBackwards == FALSE ) if ( m_fadeBackwards == FALSE ) {
{ m_grayOpacity = m_fadeTime.elapsed() / doFancyLogoutFadeTime;
m_grayOpacity = m_fadeTime.elapsed() / doFancyLogoutFadeTime; if ( m_grayOpacity > 1.0f )
if ( m_grayOpacity > 1.0f ) m_grayOpacity = 1.0f;
m_grayOpacity = 1.0f; }
} else {
else m_grayOpacity = 1.0f - m_fadeTime.elapsed() / doFancyLogoutFadeBackTime - m_compensation;
{ if ( m_grayOpacity < 0.0f )
m_grayOpacity = 1.0f - m_fadeTime.elapsed() / doFancyLogoutFadeBackTime - m_compensation; m_grayOpacity = 0.0f;
if ( m_grayOpacity < 0.0f ) }
m_grayOpacity = 0.0f;
}
const int imgWidth = m_unfadedImage.width(); const int imgWidth = m_unfadedImage.width();
int imgHeight = m_unfadedImage.height(); int imgHeight = m_unfadedImage.height();
int heightUnit = imgHeight / 3; int heightUnit = imgHeight / 3;
if( heightUnit < 1 ) if( heightUnit < 1 )
heightUnit = 1; heightUnit = 1;
int y1 = static_cast<int>( imgHeight*m_grayOpacity - heightUnit + m_grayOpacity*heightUnit*2.0f ); int y1 = static_cast<int>( imgHeight*m_grayOpacity - heightUnit + m_grayOpacity*heightUnit*2.0f );
if( y1 > imgHeight ) if( y1 > imgHeight ) {
y1 = imgHeight; y1 = imgHeight;
}
int y2 = y1+heightUnit; int y2 = y1+heightUnit;
if( y2 > imgHeight ) if( y2 > imgHeight ) {
y2 = imgHeight; y2 = imgHeight;
}
if( m_fadeBackwards == FALSE ) if( m_fadeBackwards == FALSE )
{
if( y1 > 0 && y1 < imgHeight && y1-m_rowsDone > 0 && m_rowsDone < imgHeight )
{ {
TQImage img( imgWidth, y1-m_rowsDone, 32 ); if( y1 > 0 && y1 < imgHeight && y1-m_rowsDone > 0 && m_rowsDone < imgHeight )
memcpy( img.bits(), m_grayImage.scanLine( m_rowsDone ), imgWidth*(y1-m_rowsDone)*4 ); {
bitBlt( this, 0, m_rowsDone, &img ); TQImage img( imgWidth, y1-m_rowsDone, 32 );
m_rowsDone = y1; memcpy( img.bits(), m_grayImage.scanLine( m_rowsDone ), imgWidth*(y1-m_rowsDone)*4 );
bitBlt( this, 0, m_rowsDone, &img );
m_rowsDone = y1;
}
} }
} else {
else // when fading back we have to blit area which isnt gray anymore to unfaded image
{ if( y2 > 0 && y2 < imgHeight && m_rowsDone > y2 )
// when fading back we have to blit area which isnt gray anymore to unfaded image {
if( y2 > 0 && y2 < imgHeight && m_rowsDone > y2 ) TQImage img( imgWidth, m_rowsDone-y2, 32 );
{ memcpy( img.bits(), m_unfadedImage.scanLine( y2 ), imgWidth*(m_rowsDone-y2)*4 );
TQImage img( imgWidth, m_rowsDone-y2, 32 ); bitBlt( this, 0, y2, &img );
memcpy( img.bits(), m_unfadedImage.scanLine( y2 ), imgWidth*(m_rowsDone-y2)*4 ); m_rowsDone = y2;
bitBlt( this, 0, y2, &img ); }
m_rowsDone = y2;
} }
}
int start_y1 = y1; int start_y1 = y1;
if( start_y1 < 0 ) if( start_y1 < 0 ) {
start_y1 = 0; start_y1 = 0;
if( y2 > start_y1 ) }
{ if( y2 > start_y1 ) {
TQImage img( imgWidth, y2-start_y1, 32 ); TQImage img( imgWidth, y2-start_y1, 32 );
memcpy( img.bits(), m_grayImage.scanLine( start_y1 ), ( y2-start_y1 ) * imgWidth * 4 ); memcpy( img.bits(), m_grayImage.scanLine( start_y1 ), ( y2-start_y1 ) * imgWidth * 4 );
register uchar * rs = m_unfadedImage.scanLine( start_y1 ); register uchar * rs = m_unfadedImage.scanLine( start_y1 );
register uchar * rd = img.bits(); register uchar * rd = img.bits();
for( int y = start_y1; y < y2; ++y ) for( int y = start_y1; y < y2; ++y )
{
// linear gradients look bad, so use cos-function
for( short int x = 0; x < imgWidth; ++x )
{ {
*reinterpret_cast<TQRgb*>(rd) = tqRgba(0, 0, 0, 107); // linear gradients look bad, so use cos-function
rs += 4; rd += 4; for( short int x = 0; x < imgWidth; ++x )
{
*reinterpret_cast<TQRgb*>(rd) = tqRgba(0, 0, 0, 107);
rs += 4; rd += 4;
}
} }
bitBlt( this, 0, start_y1, &img );
} }
bitBlt( this, 0, start_y1, &img );
}
TQTimer::singleShot( 1, this, TQT_SLOT( slotPaintEffect() ) ); TQTimer::singleShot( 1, this, TQT_SLOT( slotPaintEffect() ) );
} }
else { else {
if ( m_currentY >= height() ) { if ( m_currentY >= height() ) {
if ( backgroundMode() == TQWidget::NoBackground ) { if ( backgroundMode() == TQWidget::NoBackground ) {
setBackgroundMode( TQWidget::NoBackground ); setBackgroundMode( TQWidget::NoBackground );
setBackgroundPixmap( m_root ); setBackgroundPixmap( m_root );
}
return;
} }
return;
}
if ( m_currentY == 0 ) { if ( m_currentY == 0 ) {
KPixmap pixmap; setBackgroundMode( TQWidget::NoBackground );
pixmap = TQPixmap(TQPixmap::grabWindow( tqt_xrootwin(), 0, 0, width(), height() )); setGeometry( TQApplication::desktop()->geometry() );
bitBlt( this, 0, 0, &pixmap ); m_root.resize( width(), height() ); // for the default logout
bitBlt( &m_root, 0, 0, &pixmap );
} KPixmap pixmap;
pixmap = TQPixmap(TQPixmap::grabWindow( tqt_xrootwin(), 0, 0, width(), height() ));
bitBlt( this, 0, 0, &pixmap );
bitBlt( &m_root, 0, 0, &pixmap );
}
KPixmap pixmap; KPixmap pixmap;
pixmap = TQPixmap(TQPixmap::grabWindow( tqt_xrootwin(), 0, m_currentY, width(), 10 )); pixmap = TQPixmap(TQPixmap::grabWindow( tqt_xrootwin(), 0, m_currentY, width(), 10 ));
TQImage image = pixmap.convertToImage(); TQImage image = pixmap.convertToImage();
KImageEffect::blend( Qt::black, image, 0.4 ); KImageEffect::blend( Qt::black, image, 0.4 );
KImageEffect::toGray( image, true ); KImageEffect::toGray( image, true );
pixmap.convertFromImage( image ); pixmap.convertFromImage( image );
bitBlt( this, 0, m_currentY, &pixmap ); bitBlt( this, 0, m_currentY, &pixmap );
bitBlt( &m_root, 0, m_currentY, &pixmap ); bitBlt( &m_root, 0, m_currentY, &pixmap );
m_currentY += 10; m_currentY += 10;
TQTimer::singleShot( 1, this, TQT_SLOT( slotPaintEffect() ) ); TQTimer::singleShot( 1, this, TQT_SLOT( slotPaintEffect() ) );
} }
} }

Write Preview
Loading…
Cancel
Save