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.
tdebase/ksplashml/themeengine/standard/wndicon.cpp

311 lines
7.6 KiB

/***************************************************************************
* Copyright Brian Ledbetter 2001-2003 <brian@shadowcom.net> *
* Copyright Ravikiran Rajagopal 2003 *
* ravi@ee.eng.ohio-state.edu *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License (version 2) as *
* published by the Free Software Foundation. (The original KSplash/ML *
* codebase (upto version 0.95.3) is BSD-licensed.) *
* *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <tdeapplication.h>
#include <kcursor.h>
#include <kdebug.h>
#include <kdebug.h>
#include <kglobalsettings.h>
#include <twin.h>
#include <tqdesktopwidget.h>
#include <tqhbox.h>
#include <tqlabel.h>
#include <tqpixmap.h>
#include <tqpoint.h>
#include <tqtimer.h>
#include <tqwidget.h>
#include "wndicon.h"
#include "wndicon.moc"
WndIcon::WndIcon(
unsigned int icon_num,
unsigned int icon_std_width,
unsigned int status_height,
int xineramaScreen,
const KPixmap& pix,
const TQString& text,
Position icon_position,
bool statusAtTop,
bool iconsJumping )
:TQHBox( 0, "wndSplash", (WFlags)(WStyle_Customize|WX11BypassWM) ),
mStatusText(text), mIconPos(icon_position), mXineramaScreen( xineramaScreen ), mPosX(0), mPosY(0), mGroundX(0), mGroundY(0),
mVelocity(8.0), mInitialVelocity(8.0), mGravity(0.8),
mIconNum(icon_num), mStatusHeight(status_height), mIconSize(icon_std_width), mStatusAtTop(statusAtTop),
mStopJump(false), mIconJumping(iconsJumping)
{
setFrameStyle( TQFrame::NoFrame );
TQLabel *w = new TQLabel( this );
w->setFixedSize( pix.width(), pix.height() );
w->setPixmap( pix );
if(pix.mask())
{
setMask(*pix.mask());
w->setMask(*pix.mask());
}
resize( pix.width(), pix.height() );
// Set initial position of icon, and ground.
TQPoint p = determinePosition();
mGroundX = mPosX = p.x();
mGroundY = mPosY = p.y();
move( p + kapp->desktop()->screenGeometry( mXineramaScreen ).topLeft() );
if( mIconJumping )
{
TQTimer *t = new TQTimer( this );
connect(t, TQT_SIGNAL(timeout()), TQT_SLOT(slotJump()));
t->start( 50, false );
}
}
void WndIcon::show()
{
emit setStatusText( mStatusText );
TQHBox::show();
}
// Emit our EXTRA signal without becoming visible.
void WndIcon::noshow()
{
emit setStatusText( mStatusText );
}
/*
* WndIcon::determinePosition(): Based on the information we've
* stored within us, determine where we should be placed on the
* screen. This is placed in its own function due to the massive
* complexity required by the variables involved.
*/
TQPoint WndIcon::determinePosition()
{
int DW, DH, SBH, wid, X, Y, x, y, nSlot, topshift, bottomshift;
bottomshift = topshift = 0;
const TQRect srect = kapp->desktop()->screenGeometry( mXineramaScreen );
// TDEGlobalSettings::splashScreenDesktopGeometry(); cannot be used here.
DW = srect.width();
DH = srect.height();
SBH = mStatusHeight;
wid = mIconSize;
x = mIconNum;
y = 1;
if(mStatusAtTop)
topshift = mStatusHeight;
else
bottomshift = mStatusHeight;
// Different starting positions require different positioning
// rules. The horizontal rules and the vertical rules can be
// grouped together, as they are innately similar.
switch( mIconPos )
{
// HORIZONTAL: Top Left -> Top Right
case( WndIcon::HTopLeft ):
nSlot = ( DW / wid );
while( x > nSlot )
{
x = QMAX(0,x-nSlot);
y++;
}
X = (3) + ((x - 1) * wid);
Y = topshift + 3 + ( (y-1) * wid );
break;
// HORIZONTAL: Bottom Left -> Bottom Right
case( WndIcon::HBottomLeft ):
nSlot = ( DW / wid );
while( x > nSlot )
{
x = QMAX(0,x-nSlot);
y++;
}
X = (3) + ((x - 1) * wid);
Y = (DH-3) - (y * wid) - bottomshift;
break;
// HORIZONTAL: Top Right -> Top Left
case( WndIcon::HTopRight ):
nSlot = ( DW / wid );
while( x > nSlot )
{
x = QMAX(0,x-nSlot);
y++;
}
X = (DW - 3) - (( x ) * wid );
Y = topshift + (3) + ( (y-1) * wid );
break;
// HORIZONTAL: Bottom Right -> Bottom Left
case( WndIcon::HBottomRight ):
nSlot = ( DW / wid );
while( x > nSlot )
{
x = QMAX(0,x-nSlot);
y++;
}
X = (DW - 3) - (( x ) * wid );
Y = (DH-3) - (y * wid) - bottomshift;
break;
// VERTICAL: Top Left -> Bottom Left
case( WndIcon::VTopLeft ):
nSlot = ( DH / wid );
while( x > nSlot )
{
x = QMAX(0,x-nSlot);
y++;
}
X = (3) + (( y - 1 ) * wid );
Y = topshift + (3) + ((x-1) * wid);
break;
// VERTICAL: Top Right -> Bottom Right
case( WndIcon::VTopRight ):
nSlot = ( DH / wid );
while( x > nSlot )
{
x = QMAX(0,x-nSlot);
y++;
}
X = (DW - 3) - (( y ) * wid );
Y = topshift + (3) + ((x-1) * wid);
break;
// VERTICAL: Bottom Left -> Top Left
case( WndIcon::VBottomLeft ):
nSlot = ( DH / wid );
while( x > nSlot )
{
x = QMAX(0,x-nSlot);
y++;
}
X = (3) + (( y - 1 ) * wid );
Y = (DH-3) - (x * wid) - bottomshift;
break;
// VERTICAL: Bottom Right -> Top Right
case( WndIcon::VBottomRight ):
nSlot = ( DH / wid );
while( x > nSlot )
{
x = QMAX(0,x-nSlot);
y++;
}
X = (DW - 3) - (( y ) * wid );
Y = (DH-3) - (x * wid) - bottomshift;
break;
// Unknown Condition. Reconfigure variable and
// retry. Recursively, of course! ;)
default:
mIconPos = HBottomLeft;
return(determinePosition());
break;
}
return( TQPoint( X, Y ) );
}
// Make the icons jump in a macosx-like way (Thanks, Jone!:)
void WndIcon::slotJump()
{
// Based on our position, bounce around.
switch( mIconPos )
{
// LEFT
case( WndIcon::VTopLeft ):
case( WndIcon::VBottomLeft ):
mVelocity -= mGravity;
if( mStopJump )
{
if( mPosX <= mGroundX )
{
mPosX = mGroundX;
mVelocity = mGravity = 0.0;
}
}
else
if( mPosX <= mGroundX )
mVelocity = mInitialVelocity;
mPosX = (int)((float)mPosX + mVelocity);
break;
// RIGHT
case( WndIcon::VTopRight ):
case( WndIcon::VBottomRight ):
mVelocity -= mGravity;
if( mStopJump )
{
if( mPosX >= mGroundX )
{
mPosX = mGroundX;
mVelocity = mGravity = 0.0;
}
}
else
if( mPosX >= mGroundX )
mVelocity = mInitialVelocity;
mPosX = (int)((float)mPosX - mVelocity);
break;
// TOP
case( WndIcon::HTopLeft ):
case( WndIcon::HTopRight ):
mVelocity -= mGravity;
if( mStopJump )
{
if( mPosY <= mGroundY )
{
mPosY = mGroundY;
mVelocity = mGravity = 0.0;
}
}
else
if( mPosY <= mGroundY )
mVelocity = mInitialVelocity;
mPosY = (int)((float)mPosY + mVelocity );
break;
// BOTTOM
case( WndIcon::HBottomLeft ):
case( WndIcon::HBottomRight ): default:
mVelocity -= mGravity;
if( mStopJump )
{
if( mPosY >= mGroundY )
{
mPosY = mGroundY;
mVelocity = mGravity = 0.0;
}
}
else
if( mPosY >= mGroundY )
mVelocity = mInitialVelocity;
mPosY = (int)((float)mPosY - mVelocity );
break;
}
move( TQPoint( mPosX, mPosY ) + kapp->desktop()->screenGeometry( mXineramaScreen ).topLeft() );
}
void WndIcon::slotStopJumping()
{
mStopJump = true;
}