You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
603 lines
15 KiB
603 lines
15 KiB
#if 0
|
|
|
|
// Note: this file has been copied from the TQt source.
|
|
// Those classes are normally used internally in TQt
|
|
// but we need them for immitate the roll-over effect of TQComboBox.
|
|
//
|
|
// A portion of code has been added. It's underlined by "THIS CODE WAS ADDED:".
|
|
//
|
|
// And some class definitions have been moved from this file to qeffects.h
|
|
// Theire old position is indicated by "REMOVED CLASS DEFINITION HERE (MOVED TO qeffects.h)"
|
|
|
|
/****************************************************************************
|
|
** $Id: qt/qeffects.cpp 3.3.4 edited Dec 10 10:13 $
|
|
**
|
|
** Implementation of TQEffects functions
|
|
**
|
|
** Created : 000621
|
|
**
|
|
** Copyright (C) 2000 Trolltech AS. All rights reserved.
|
|
**
|
|
** This file is part of the widgets module of the TQt GUI Toolkit.
|
|
**
|
|
** This file may be distributed under the terms of the Q Public License
|
|
** as defined by Trolltech AS of Norway and appearing in the file
|
|
** LICENSE.TQPL included in the packaging of this file.
|
|
**
|
|
** This file may be distributed and/or modified under the terms of the
|
|
** GNU General Public License version 2 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL included in the
|
|
** packaging of this file.
|
|
**
|
|
** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition
|
|
** licenses may use this file in accordance with the TQt Commercial License
|
|
** Agreement provided with the Software.
|
|
**
|
|
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
|
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
**
|
|
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
|
|
** information about TQt Commercial License Agreements.
|
|
** See http://www.trolltech.com/qpl/ for TQPL licensing information.
|
|
** See http://www.trolltech.com/gpl/ for GPL licensing information.
|
|
**
|
|
** Contact info@trolltech.com if any conditions of this licensing are
|
|
** not clear to you.
|
|
**
|
|
**********************************************************************/
|
|
|
|
#include "tqapplication.h"
|
|
#ifndef TQT_NO_EFFECTS
|
|
#include "tqwidget.h"
|
|
#include "tqeffects.h"
|
|
#include "tqpixmap.h"
|
|
#include "tqimage.h"
|
|
#include "tqtimer.h"
|
|
#include "tqdatetime.h"
|
|
#include "tqguardedptr.h"
|
|
#include "tqscrollview.h"
|
|
|
|
/* REMOVED CLASS DEFINITION HERE (MOVED TO qeffects.h) */
|
|
|
|
static TQAlphaWidget* q_blend = 0;
|
|
|
|
/*
|
|
Constructs a TQAlphaWidget.
|
|
*/
|
|
TQAlphaWidget::TQAlphaWidget( TQWidget* w, WFlags f )
|
|
: TQWidget( TQApplication::desktop()->screen(TQApplication::desktop()->screenNumber(w)),
|
|
"tqt internal alpha effect widget", f )
|
|
{
|
|
#if 1 //ndef TQ_WS_WIN
|
|
setEnabled( FALSE );
|
|
#endif
|
|
|
|
pm.setOptimization( TQPixmap::BestOptim );
|
|
setBackgroundMode( NoBackground );
|
|
widget = (TQAccessWidget*)w;
|
|
alpha = 0;
|
|
}
|
|
|
|
/*
|
|
\reimp
|
|
*/
|
|
void TQAlphaWidget::paintEvent( TQPaintEvent* )
|
|
{
|
|
bitBlt( this, TQPoint(0,0), &pm );
|
|
}
|
|
|
|
/*
|
|
Starts the alphablending animation.
|
|
The animation will take about \a time ms
|
|
*/
|
|
void TQAlphaWidget::run( int time )
|
|
{
|
|
duration = time;
|
|
|
|
if ( duration < 0 )
|
|
duration = 150;
|
|
|
|
if ( !widget )
|
|
return;
|
|
|
|
elapsed = 0;
|
|
checkTime.start();
|
|
|
|
showWidget = TRUE;
|
|
tqApp->installEventFilter( this );
|
|
|
|
widget->setWState( WState_Visible );
|
|
|
|
move( widget->geometry().x(),widget->geometry().y() );
|
|
resize( widget->size().width(), widget->size().height() );
|
|
|
|
front = TQImage( widget->size(), 32 );
|
|
front = TQPixmap::grabWidget( widget );
|
|
|
|
back = TQImage( widget->size(), 32 );
|
|
back = TQPixmap::grabWindow( TQApplication::desktop()->winId(),
|
|
widget->geometry().x(), widget->geometry().y(),
|
|
widget->geometry().width(), widget->geometry().height() );
|
|
|
|
if ( !back.isNull() && checkTime.elapsed() < duration / 2 ) {
|
|
mixed = back.copy();
|
|
pm = mixed;
|
|
show();
|
|
setEnabled(FALSE);
|
|
|
|
connect( &anim, TQ_SIGNAL(timeout()), this, TQ_SLOT(render()));
|
|
anim.start( 1 );
|
|
} else {
|
|
duration = 0;
|
|
render();
|
|
}
|
|
}
|
|
|
|
/*
|
|
\reimp
|
|
*/
|
|
bool TQAlphaWidget::eventFilter( TQObject* o, TQEvent* e )
|
|
{
|
|
switch ( e->type() ) {
|
|
case TQEvent::Move:
|
|
if ( o != widget )
|
|
break;
|
|
move( widget->geometry().x(),widget->geometry().y() );
|
|
update();
|
|
break;
|
|
case TQEvent::Hide:
|
|
case TQEvent::Close:
|
|
if ( o != widget )
|
|
break;
|
|
case TQEvent::MouseButtonPress:
|
|
#ifndef TQT_NO_SCROLLVIEW
|
|
if ( ::tqt_cast<TQScrollView*>(o) )
|
|
break;
|
|
#endif
|
|
case TQEvent::MouseButtonDblClick:
|
|
setEnabled(TRUE);
|
|
showWidget = FALSE;
|
|
render();
|
|
break;
|
|
case TQEvent::KeyPress:
|
|
{
|
|
TQKeyEvent *ke = (TQKeyEvent*)e;
|
|
if ( ke->key() == Key_Escape )
|
|
showWidget = FALSE;
|
|
else
|
|
duration = 0;
|
|
render();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return TQWidget::eventFilter( o, e );
|
|
}
|
|
|
|
/*
|
|
\reimp
|
|
*/
|
|
void TQAlphaWidget::closeEvent( TQCloseEvent *e )
|
|
{
|
|
e->accept();
|
|
if ( !q_blend )
|
|
return;
|
|
|
|
showWidget = FALSE;
|
|
render();
|
|
|
|
TQWidget::closeEvent( e );
|
|
}
|
|
|
|
/*
|
|
Render alphablending for the time elapsed.
|
|
|
|
Show the blended widget and free all allocated source
|
|
if the blending is finished.
|
|
*/
|
|
void TQAlphaWidget::render()
|
|
{
|
|
int tempel = checkTime.elapsed();
|
|
if ( elapsed >= tempel )
|
|
elapsed++;
|
|
else
|
|
elapsed = tempel;
|
|
|
|
if ( duration != 0 )
|
|
alpha = tempel / double(duration);
|
|
else
|
|
alpha = 1;
|
|
if ( alpha >= 1 || !showWidget) {
|
|
anim.stop();
|
|
tqApp->removeEventFilter( this );
|
|
|
|
if ( widget ) {
|
|
if ( !showWidget ) {
|
|
#ifdef TQ_WS_WIN
|
|
setEnabled(TRUE);
|
|
setFocus();
|
|
#endif
|
|
widget->hide();
|
|
widget->setWState( WState_ForceHide );
|
|
widget->clearWState( WState_Visible );
|
|
} else if ( duration ) {
|
|
BackgroundMode bgm = widget->backgroundMode();
|
|
TQColor erc = widget->eraseColor();
|
|
const TQPixmap *erp = widget->erasePixmap();
|
|
|
|
widget->clearWState( WState_Visible );
|
|
widget->setBackgroundMode( NoBackground );
|
|
widget->show();
|
|
if ( bgm != FixedColor && bgm != FixedPixmap ) {
|
|
widget->clearWState( WState_Visible ); // prevent update in setBackgroundMode
|
|
widget->setBackgroundMode( bgm );
|
|
widget->setWState( WState_Visible );
|
|
}
|
|
if ( erc.isValid() ) {
|
|
widget->setEraseColor( erc );
|
|
} else if ( erp ) {
|
|
widget->setErasePixmap( *erp );
|
|
}
|
|
} else {
|
|
widget->clearWState( WState_Visible );
|
|
widget->show();
|
|
}
|
|
}
|
|
q_blend = 0;
|
|
deleteLater();
|
|
} else {
|
|
if (widget)
|
|
widget->clearWState( WState_ForceHide );
|
|
alphaBlend();
|
|
pm = mixed;
|
|
repaint( FALSE );
|
|
}
|
|
}
|
|
|
|
/*
|
|
Calculate an alphablended image.
|
|
*/
|
|
void TQAlphaWidget::alphaBlend()
|
|
{
|
|
const double ia = 1-alpha;
|
|
const int sw = front.width();
|
|
const int sh = front.height();
|
|
switch( front.depth() ) {
|
|
case 32:
|
|
{
|
|
TQ_UINT32** md = (TQ_UINT32**)mixed.jumpTable();
|
|
TQ_UINT32** bd = (TQ_UINT32**)back.jumpTable();
|
|
TQ_UINT32** fd = (TQ_UINT32**)front.jumpTable();
|
|
|
|
for (int sy = 0; sy < sh; sy++ ) {
|
|
TQ_UINT32* bl = ((TQ_UINT32*)bd[sy]);
|
|
TQ_UINT32* fl = ((TQ_UINT32*)fd[sy]);
|
|
for (int sx = 0; sx < sw; sx++ ) {
|
|
TQ_UINT32 bp = bl[sx];
|
|
TQ_UINT32 fp = fl[sx];
|
|
|
|
((TQ_UINT32*)(md[sy]))[sx] = tqRgb(int (tqRed(bp)*ia + tqRed(fp)*alpha),
|
|
int (tqGreen(bp)*ia + tqGreen(fp)*alpha),
|
|
int (tqBlue(bp)*ia + tqBlue(fp)*alpha) );
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* REMOVED CLASS DEFINITION HERE (MOVED TO qeffects.h) */
|
|
|
|
static TQRollEffect* q_roll = 0;
|
|
|
|
/*
|
|
Construct a TQRollEffect widget.
|
|
*/
|
|
TQRollEffect::TQRollEffect( TQWidget* w, WFlags f, DirFlags orient )
|
|
: TQWidget( TQApplication::desktop()->screen(TQApplication::desktop()->screenNumber(w)),
|
|
"tqt internal roll effect widget", f ), orientation(orient)
|
|
{
|
|
#if 1 //ndef TQ_WS_WIN
|
|
setEnabled( FALSE );
|
|
#endif
|
|
widget = (TQAccessWidget*) w;
|
|
Q_ASSERT( widget );
|
|
|
|
setBackgroundMode( NoBackground );
|
|
|
|
if ( widget->testWState( WState_Resized ) ) {
|
|
totalWidth = widget->width();
|
|
totalHeight = widget->height();
|
|
} else {
|
|
totalWidth = widget->sizeHint().width();
|
|
totalHeight = widget->sizeHint().height();
|
|
}
|
|
|
|
currentHeight = totalHeight;
|
|
currentWidth = totalWidth;
|
|
|
|
if ( orientation & (RightScroll|LeftScroll) )
|
|
currentWidth = 0;
|
|
if ( orientation & (DownScroll|UpScroll) )
|
|
currentHeight = 0;
|
|
|
|
pm.setOptimization( TQPixmap::BestOptim );
|
|
pm = TQPixmap::grabWidget( widget );
|
|
}
|
|
|
|
/*
|
|
\reimp
|
|
*/
|
|
void TQRollEffect::paintEvent( TQPaintEvent* )
|
|
{
|
|
int x = orientation & RightScroll ? TQMIN(0, currentWidth - totalWidth) : 0;
|
|
int y = orientation & DownScroll ? TQMIN(0, currentHeight - totalHeight) : 0;
|
|
|
|
bitBlt( this, x, y, &pm,
|
|
0, 0, pm.width(), pm.height(), CopyROP, TRUE );
|
|
}
|
|
|
|
/*
|
|
\reimp
|
|
*/
|
|
bool TQRollEffect::eventFilter( TQObject* o, TQEvent* e )
|
|
{
|
|
switch ( e->type() ) {
|
|
case TQEvent::Move:
|
|
if ( o != widget )
|
|
break;
|
|
move( widget->geometry().x(),widget->geometry().y() );
|
|
update();
|
|
break;
|
|
case TQEvent::Hide:
|
|
case TQEvent::Close:
|
|
if ( o != widget || done )
|
|
break;
|
|
setEnabled(TRUE);
|
|
showWidget = FALSE;
|
|
done = TRUE;
|
|
scroll();
|
|
break;
|
|
case TQEvent::MouseButtonPress:
|
|
#ifndef TQT_NO_SCROLLVIEW
|
|
if ( ::tqt_cast<TQScrollView*>(o) )
|
|
break;
|
|
#endif
|
|
case TQEvent::MouseButtonDblClick:
|
|
if ( done )
|
|
break;
|
|
setEnabled(TRUE);
|
|
showWidget = FALSE;
|
|
done = TRUE;
|
|
scroll();
|
|
break;
|
|
case TQEvent::KeyPress:
|
|
{
|
|
TQKeyEvent *ke = (TQKeyEvent*)e;
|
|
|
|
|
|
/* THIS CODE WAS ADDED: ************** */
|
|
if (ke->key() == TQt::Key_Enter) /*** Because we are simulating an Enter key press. */
|
|
break; /*** So we should not car about it and continue the animation. */
|
|
/************************************* */
|
|
|
|
|
|
if ( ke->key() == Key_Escape )
|
|
showWidget = FALSE;
|
|
done = TRUE;
|
|
scroll();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return TQWidget::eventFilter( o, e );
|
|
}
|
|
|
|
/*
|
|
\reimp
|
|
*/
|
|
void TQRollEffect::closeEvent( TQCloseEvent *e )
|
|
{
|
|
e->accept();
|
|
if ( done )
|
|
return;
|
|
showWidget = FALSE;
|
|
done = TRUE;
|
|
scroll();
|
|
|
|
TQWidget::closeEvent( e );
|
|
}
|
|
|
|
/*
|
|
Start the animation.
|
|
|
|
The animation will take about \a time ms, or is
|
|
calculated if \a time is negative
|
|
*/
|
|
void TQRollEffect::run( int time )
|
|
{
|
|
if ( !widget )
|
|
return;
|
|
|
|
duration = time;
|
|
elapsed = 0;
|
|
|
|
if ( duration < 0 ) {
|
|
int dist = 0;
|
|
if ( orientation & (RightScroll|LeftScroll) )
|
|
dist += totalWidth - currentWidth;
|
|
if ( orientation & (DownScroll|UpScroll) )
|
|
dist += totalHeight - currentHeight;
|
|
duration = TQMIN( TQMAX( dist/3, 50 ), 120 );
|
|
}
|
|
|
|
connect( &anim, TQ_SIGNAL(timeout()), this, TQ_SLOT(scroll()));
|
|
|
|
widget->setWState( WState_Visible );
|
|
|
|
move( widget->geometry().x(),widget->geometry().y() );
|
|
resize( TQMIN( currentWidth, totalWidth ), TQMIN( currentHeight, totalHeight ) );
|
|
|
|
show();
|
|
setEnabled(FALSE);
|
|
|
|
tqApp->installEventFilter( this );
|
|
|
|
showWidget = TRUE;
|
|
done = FALSE;
|
|
anim.start( 1 );
|
|
checkTime.start();
|
|
}
|
|
|
|
/*
|
|
Roll according to the time elapsed.
|
|
*/
|
|
void TQRollEffect::scroll()
|
|
{
|
|
if ( !done && widget) {
|
|
widget->clearWState( WState_ForceHide );
|
|
int tempel = checkTime.elapsed();
|
|
if ( elapsed >= tempel )
|
|
elapsed++;
|
|
else
|
|
elapsed = tempel;
|
|
|
|
if ( currentWidth != totalWidth ) {
|
|
currentWidth = totalWidth * (elapsed/duration)
|
|
+ ( 2 * totalWidth * (elapsed%duration) + duration )
|
|
/ ( 2 * duration );
|
|
// equiv. to int( (totalWidth*elapsed) / duration + 0.5 )
|
|
done = (currentWidth >= totalWidth);
|
|
}
|
|
if ( currentHeight != totalHeight ) {
|
|
currentHeight = totalHeight * (elapsed/duration)
|
|
+ ( 2 * totalHeight * (elapsed%duration) + duration )
|
|
/ ( 2 * duration );
|
|
// equiv. to int( (totalHeight*elapsed) / duration + 0.5 )
|
|
done = (currentHeight >= totalHeight);
|
|
}
|
|
done = ( currentHeight >= totalHeight ) &&
|
|
( currentWidth >= totalWidth );
|
|
|
|
int w = totalWidth;
|
|
int h = totalHeight;
|
|
int x = widget->geometry().x();
|
|
int y = widget->geometry().y();
|
|
|
|
if ( orientation & RightScroll || orientation & LeftScroll )
|
|
w = TQMIN( currentWidth, totalWidth );
|
|
if ( orientation & DownScroll || orientation & UpScroll )
|
|
h = TQMIN( currentHeight, totalHeight );
|
|
|
|
setUpdatesEnabled( FALSE );
|
|
if ( orientation & UpScroll )
|
|
y = widget->geometry().y() + TQMAX( 0, totalHeight - currentHeight );
|
|
if ( orientation & LeftScroll )
|
|
x = widget->geometry().x() + TQMAX( 0, totalWidth - currentWidth );
|
|
if ( orientation & UpScroll || orientation & LeftScroll )
|
|
move( x, y );
|
|
|
|
resize( w, h );
|
|
setUpdatesEnabled( TRUE );
|
|
repaint( FALSE );
|
|
}
|
|
if ( done ) {
|
|
anim.stop();
|
|
tqApp->removeEventFilter( this );
|
|
if ( widget ) {
|
|
if ( !showWidget ) {
|
|
#ifdef TQ_WS_WIN
|
|
setEnabled(TRUE);
|
|
setFocus();
|
|
#endif
|
|
widget->hide();
|
|
widget->setWState( WState_ForceHide );
|
|
widget->clearWState( WState_Visible );
|
|
} else {
|
|
BackgroundMode bgm = widget->backgroundMode();
|
|
TQColor erc = widget->eraseColor();
|
|
const TQPixmap *erp = widget->erasePixmap();
|
|
|
|
widget->clearWState( WState_Visible );
|
|
widget->setBackgroundMode( NoBackground );
|
|
widget->show();
|
|
if ( bgm != FixedColor && bgm != FixedPixmap ) {
|
|
widget->clearWState( WState_Visible ); // prevent update in setBackgroundMode
|
|
widget->setBackgroundMode( bgm );
|
|
widget->setWState( WState_Visible );
|
|
}
|
|
if ( erc.isValid() ) {
|
|
widget->setEraseColor( erc );
|
|
} else if ( erp ) {
|
|
widget->setErasePixmap( *erp );
|
|
}
|
|
}
|
|
}
|
|
q_roll = 0;
|
|
deleteLater();
|
|
}
|
|
}
|
|
|
|
/*
|
|
Delete this after timeout
|
|
*/
|
|
|
|
#include "qeffects.moc"
|
|
|
|
/*!
|
|
Scroll widget \a w in \a time ms. \a orient may be 1 (vertical), 2
|
|
(horizontal) or 3 (diagonal).
|
|
*/
|
|
void qScrollEffect( TQWidget* w, TQEffects::DirFlags orient, int time )
|
|
{
|
|
if ( q_roll ) {
|
|
delete q_roll;
|
|
q_roll = 0;
|
|
}
|
|
|
|
tqApp->sendPostedEvents( w, TQEvent::Move );
|
|
tqApp->sendPostedEvents( w, TQEvent::Resize );
|
|
#ifdef TQ_WS_X11
|
|
uint flags = TQt::WStyle_Customize | TQt::WNoAutoErase | TQt::WStyle_StaysOnTop
|
|
| (w->isPopup() ? TQt::WType_Popup : (TQt::WX11BypassWM | TQt::WStyle_Tool));
|
|
#else
|
|
uint flags = TQt::WStyle_Customize | TQt::WType_Popup | TQt::WX11BypassWM | TQt::WNoAutoErase | TQt::WStyle_StaysOnTop;
|
|
#endif
|
|
|
|
// those can popups - they would steal the focus, but are disabled
|
|
q_roll = new TQRollEffect( w, flags, orient );
|
|
q_roll->run( time );
|
|
}
|
|
|
|
/*!
|
|
Fade in widget \a w in \a time ms.
|
|
*/
|
|
void qFadeEffect( TQWidget* w, int time )
|
|
{
|
|
if ( q_blend ) {
|
|
delete q_blend;
|
|
q_blend = 0;
|
|
}
|
|
|
|
tqApp->sendPostedEvents( w, TQEvent::Move );
|
|
tqApp->sendPostedEvents( w, TQEvent::Resize );
|
|
|
|
#ifdef TQ_WS_X11
|
|
uint flags = TQt::WStyle_Customize | TQt::WNoAutoErase | TQt::WStyle_StaysOnTop
|
|
| (w->isPopup() ? TQt::WType_Popup : (TQt::WX11BypassWM | TQt::WStyle_Tool));
|
|
#else
|
|
uint flags = TQt::WStyle_Customize | TQt::WType_Popup | TQt::WX11BypassWM | TQt::WNoAutoErase | TQt::WStyle_StaysOnTop;
|
|
#endif
|
|
|
|
// those can popups - they would steal the focus, but are disabled
|
|
q_blend = new TQAlphaWidget( w, flags );
|
|
|
|
q_blend->run( time );
|
|
}
|
|
#endif //TQT_NO_EFFECTS
|
|
|
|
#endif // #if 0
|