//==================================================================================
//
// File : notifierwindow.cpp
// Creation date : Tue Jul 6 2004 20:25:12 CEST by Szymon Stefanek
//
// This file is part of the KVirc irc client distribution
// Copyright (C) 2004 Iacopo Palazzi < iakko(at)siena.linux.it >
//
// This program is FREE software. You can redistribute it and/or
// modify it under the linkss of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your opinion) any later version.
//
// This program is distributed in the HOPE that it will be USEFUL,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, write to the Free Software Foundation,
// Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
//==================================================================================
# include "kvi_settings.h"
# ifdef COMPILE_USE_QT4
# define TQPopupMenu Q3PopupMenu
# define TQSimpleRichText Q3SimpleRichText
# include <tq3popupmenu.h>
# include <tq3simplerichtext.h>
# else
# include <tqpopupmenu.h>
# include <tqsimplerichtext.h>
# endif
# include <tqpainter.h>
# include "notifiermessage.h"
# include "notifierwindow.h"
# include "kvi_iconmanager.h"
# include "kvi_config.h"
# include "kvi_app.h"
# include "kvi_window.h"
# include "kvi_locale.h"
# include "kvi_frame.h"
# include "kvi_mirccntrl.h"
# include "kvi_options.h"
# include "kvi_userinput.h"
# include <tqapplication.h>
# include <tqimage.h>
# include <tqdesktopwidget.h>
# include <tqtooltip.h>
# include <tqevent.h>
# include <tqpen.h>
# include <tqfontmetrics.h>
# include <tqregexp.h>
# include "notifierwindowbody.h"
# include "notifierwindowborder.h"
# include "notifierwindowprogressbar.h"
# include "notifierwindowtabs.h"
extern KviNotifierWindow * g_pNotifierWindow ;
KviNotifierWindow : : KviNotifierWindow ( )
: TQWidget ( 0 , " kvirc_notifier_window " ,
# ifdef COMPILE_ON_WINDOWS
TQt : : WStyle_Customize |
TQt : : WStyle_NoBorder |
TQt : : WStyle_Tool |
TQt : : WStyle_StaysOnTop )
# else
TQt : : WStyle_Customize |
TQt : : WStyle_NoBorder |
# ifndef Q_OS_MACX
TQt : : WStyle_Tool |
TQt : : WX11BypassWM |
# endif
TQt : : WStyle_StaysOnTop )
# endif
{
g_pNotifierWindow = this ;
m_eState = Hidden ;
m_dOpacity = 0.0 ;
m_pShowHideTimer = 0 ;
m_pBlinkTimer = 0 ;
m_tAutoHideAt = 0 ;
m_tStartedAt = 0 ;
m_pAutoHideTimer = 0 ;
m_pProgressTimer = 0 ;
m_pWndBorder = new KviNotifierWindowBorder ( ) ;
reloadImages ( ) ;
KviStr buffer ;
g_pApp - > getReadOnlyConfigPath ( buffer , " libkvinotifier.kvc " , KviApp : : ConfigPlugins , true ) ;
KviConfig cfg ( buffer . ptr ( ) , KviConfig : : Read ) ;
cfg . setGroup ( " NotifierSkin " ) ;
TQString szFamily = cfg . readEntry ( " TextFontFamily " , " Arial " ) ;
m_pDefaultFont = new TQFont ( szFamily , cfg . readIntEntry ( " TextFontSize " , 9 ) ) ;
szFamily = cfg . readEntry ( " TitleFontFamily " , " Arial " ) ;
m_pTitleFont = new TQFont ( szFamily , cfg . readIntEntry ( " TitleFontSize " , 9 ) ) ;
m_clrCurText = cfg . readColorEntry ( " CurTextColor " , TQColor ( 40 , 0 , 0 ) ) ;
m_clrHistoricText = cfg . readColorEntry ( " HistoricTextColor " , TQColor ( 125 , 125 , 125 ) ) ;
m_clrTitle = TQColor ( 255 , 255 , 255 ) ; //cfg.readColorEntry("TitleColor",TQColor(0,0,0));
for ( int i = 0 ; i < NUM_OLD_COLORS ; i + + )
{
KviStr szKey ;
szKey . sprintf ( " OldTextColor%d " , i + 1 ) ;
m_clrOldText [ i ] = cfg . readColorEntry ( szKey . ptr ( ) , TQColor ( 90 , 90 , 90 ) ) ;
}
m_iBlinkTimeout = cfg . readIntEntry ( " BlinkTimeout " , 650 ) ;
if ( m_iBlinkTimeout < 100 ) m_iBlinkTimeout = 100 ;
m_iInputHeight = cfg . readIntEntry ( " InputHeight " , 20 ) ;
if ( m_iInputHeight < 10 ) m_iInputHeight = 10 ;
setBackgroundMode ( TQt : : NoBackground ) ;
# ifdef COMPILE_USE_QT4
setFocusPolicy ( TTQ_NoFocus ) ;
# else
setFocusPolicy ( TQ_NoFocus ) ;
# endif
setMouseTracking ( true ) ;
//setCursor(m_cursor);
hide ( ) ;
m_pLineEdit = new TQLineEdit ( this ) ;
m_pLineEdit - > setGeometry ( 0 , 0 , 0 , 0 ) ;
m_pLineEdit - > hide ( ) ;
m_pLineEdit - > installEventFilter ( this ) ;
connect ( m_pLineEdit , TQT_SIGNAL ( returnPressed ( ) ) , this , TQT_SLOT ( returnPressed ( ) ) ) ;
szFamily = cfg . readEntry ( " InputFontFamily " , " Arial " ) ;
m_pLineEdit - > setFont ( TQFont ( szFamily , cfg . readIntEntry ( " InputFontSize " , 9 ) ) ) ;
m_bBlinkOn = false ;
m_bCloseDown = false ;
m_bPrevDown = false ;
m_bNextDown = false ;
m_bWriteDown = false ;
m_bKeyShiftPressed = false ;
m_bLeftButtonIsPressed = false ;
m_bDiagonalResizing = false ;
m_bResizing = false ;
m_pContextPopup = 0 ;
m_pDisablePopup = 0 ;
m_bDragging = false ;
m_bDisableHideOnMainWindowGotAttention = false ;
// Positioning the notifier bottom-right
int iWidth = m_pixBackground . width ( ) ;
int iHeight = m_pixBackground . height ( ) ;
TQDesktopWidget * w = TQApplication : : desktop ( ) ;
TQRect r = w - > availableGeometry ( w - > primaryScreen ( ) ) ; //w->screenGeometry(w->primaryScreen());
/*debug("r.x(),r.y(): %d,%d",r.x(),r.y());
debug ( " r.width(),r.height(): %d,%d " , r . width ( ) , r . height ( ) ) ; */
m_wndRect . setRect ( r . x ( ) + r . width ( ) - ( iWidth + SPACING ) , r . y ( ) + r . height ( ) - ( iHeight + SPACING ) , iWidth , iHeight ) ;
//m_pWndBorder = new KviNotifierWindowBorder();
m_pWndTabs = new KviNotifierWindowTabs ( m_pWndBorder - > tabsRect ( ) ) ;
m_pWndBody = new KviNotifierWindowBody ( m_pWndBorder - > bodyRect ( ) ) ;
m_pProgressBar = new KviNotifierWindowProgressBar ( m_pWndBorder - > progressRect ( ) ) ;
// FIXME: Ugly global-font initialization..
TQFontMetrics titleFontMetrics ( * m_pTitleFont ) ;
m_pWndBorder - > centerTitle ( titleFontMetrics . height ( ) ) ;
connect ( g_pApp , TQT_SIGNAL ( reloadImages ( ) ) , this , TQT_SLOT ( reloadImages ( ) ) ) ;
}
KviNotifierWindow : : ~ KviNotifierWindow ( )
{
stopShowHideTimer ( ) ;
stopBlinkTimer ( ) ;
stopAutoHideTimer ( ) ;
delete m_pDefaultFont ;
delete m_pTitleFont ;
delete m_pWndBorder ;
delete m_pWndTabs ;
delete m_pWndBody ;
}
int KviNotifierWindow : : countTabs ( ) {
return m_pWndTabs - > count ( ) ;
}
void KviNotifierWindow : : reloadImages ( )
{
m_pixBackground . resize ( WDG_MIN_WIDTH , WDG_MIN_HEIGHT ) ;
m_pixBackground . fill ( ) ;
m_pixBackgroundHighlighted . resize ( m_pixBackground . size ( ) ) ;
m_pixBackgroundHighlighted . fill ( ) ;
m_pWndBorder - > resize ( m_pixBackground . size ( ) ) ;
}
void KviNotifierWindow : : addMessage ( KviWindow * pWnd , const TQString & szImageId , const TQString & szText , unsigned int uMessageTime )
{
TQPixmap * pIcon ;
TQString szMessage = szText ;
szMessage . tqreplace ( TQRegExp ( " \r ([^ \r ])* \r ([^ \r ])+ \r " ) , " \\ 2 " ) ;
if ( szImageId . isEmpty ( ) ) pIcon = 0 ;
else pIcon = g_pIconManager - > getImage ( szImageId ) ;
KviNotifierMessage * m = new KviNotifierMessage ( this , pIcon ? new TQPixmap ( * pIcon ) : 0 , szMessage ) ;
m_pWndTabs - > addMessage ( pWnd , m ) ; // Adds a tab about the sender pWnd
if ( ! isActiveWindow ( ) )
startBlinking ( ) ;
if ( uMessageTime > 0 )
{
kvi_time_t tAutoHide = kvi_unixTime ( ) + uMessageTime ;
if ( m_tAutoHideAt < tAutoHide )
{
m_tAutoHideAt = tAutoHide ;
if ( m_eState = = Visible ) startAutoHideTimer ( ) ;
}
} else {
// never hide
stopAutoHideTimer ( ) ;
m_tAutoHideAt = 0 ;
}
if ( pWnd )
{
if ( pWnd - > hasAttention ( ) ) m_bDisableHideOnMainWindowGotAttention = true ;
}
//m_pWndTabs->setCurrentMessage(m);
if ( isVisible ( ) ) update ( ) ;
// else the line edit was hidden
}
int KviNotifierWindow : : textWidth ( ) {
return m_pWndBody - > textRect ( ) . width ( ) - 20 ;
} ;
void KviNotifierWindow : : stopShowHideTimer ( )
{
if ( ! m_pShowHideTimer ) return ;
delete m_pShowHideTimer ;
m_pShowHideTimer = 0 ;
}
void KviNotifierWindow : : stopBlinkTimer ( )
{
if ( ! m_pBlinkTimer ) return ;
delete m_pBlinkTimer ;
m_pBlinkTimer = 0 ;
}
void KviNotifierWindow : : stopAutoHideTimer ( )
{
if ( m_pProgressTimer ) delete m_pProgressTimer ;
m_pProgressTimer = 0 ;
if ( ! m_pAutoHideTimer ) return ;
delete m_pAutoHideTimer ;
m_pAutoHideTimer = 0 ;
m_pProgressBar - > setProgress ( 0 ) ;
}
void KviNotifierWindow : : computeRect ( )
{
int iWidth = m_pixBackground . width ( ) ;
int iHeight = m_pixBackground . height ( ) ;
m_pWndBorder - > setGeometry ( TQPoint ( x ( ) , y ( ) ) , TQSize ( iWidth , iHeight ) ) ;
update ( ) ;
}
void KviNotifierWindow : : doShow ( bool bDoAnimate )
{
if ( KVI_OPTION_BOOL ( KviOption_boolForciblyDisableNotifier ) ) return ;
kvi_time_t tNow = kvi_unixTime ( ) ;
if ( g_tNotifierDisabledUntil > tNow ) return ;
g_tNotifierDisabledUntil = 0 ;
switch ( m_eState )
{
case Showing :
// already showing up
return ;
break ;
case Visible :
// already visible
return ;
break ;
case Hiding :
// ops.. hiding!
m_eState = Showing ;
break ;
case Hidden :
stopShowHideTimer ( ) ;
stopBlinkTimer ( ) ;
m_bDragging = false ;
m_bCloseDown = false ;
m_bPrevDown = false ;
m_bNextDown = false ;
m_bWriteDown = false ;
m_bBlinkOn = false ;
# if (!defined COMPILE_USE_QT4) || !(defined(COMPILE_USE_QT4) && (defined(COMPILE_ON_WINDOWS) || defined(Q_OS_MACX)))
m_imgDesktop = TQPixmap ( TQPixmap : : grabWindow (
TQApplication : : desktop ( ) - > winId ( ) ,
m_wndRect . x ( ) ,
m_wndRect . y ( ) ,
m_wndRect . width ( ) ,
m_wndRect . height ( ) ) ) . convertToImage ( ) ;
# endif
// TQPixmap tmp = TQPixmap::grabWindow( TQApplication::desktop()->winId(),m_wndRect.x(), m_wndRect.y(), m_wndRect.width(), m_wndRect.height());
// tmp.save("/root/pix.png","PNG");
m_pixForeground . resize ( m_pixBackground . size ( ) ) ;
m_imgBuffer . create ( m_pixBackground . width ( ) , m_pixBackground . height ( ) , 32 ) ;
if ( bDoAnimate )
{
m_pShowHideTimer = new TQTimer ( ) ;
connect ( m_pShowHideTimer , TQT_SIGNAL ( timeout ( ) ) , this , TQT_SLOT ( heartbeat ( ) ) ) ;
m_dOpacity = OPACITY_STEP ;
m_eState = Showing ;
m_bCrashShowWorkAround = true ;
# if defined(COMPILE_USE_QT4) && (defined(COMPILE_ON_WINDOWS) || defined(Q_OS_MACX))
setWindowOpacity ( m_dOpacity ) ;
# endif
show ( ) ;
# if defined(COMPILE_USE_QT4) && (defined(COMPILE_ON_WINDOWS) || defined(Q_OS_MACX))
m_pShowHideTimer - > start ( 40 ) ;
# else
m_pShowHideTimer - > start ( 100 ) ;
# endif
computeRect ( ) ;
m_bCrashShowWorkAround = false ;
//show();
} else {
m_dOpacity = 1.0 ;
m_eState = Visible ;
show ( ) ;
startBlinking ( ) ;
startAutoHideTimer ( ) ;
}
break ;
}
}
bool KviNotifierWindow : : shouldHideIfMainWindowGotAttention ( )
{
if ( m_bDisableHideOnMainWindowGotAttention ) return false ;
KviNotifierWindowTab * t = m_pWndTabs - > currentTab ( ) ;
if ( ! t ) return false ;
if ( ! t - > window ( ) ) return false ;
return t - > window ( ) - > hasAttention ( ) ;
}
void KviNotifierWindow : : heartbeat ( )
{
bool bIncreasing ;
double targetOpacity = 0 ; //qt4
switch ( m_eState )
{
case Hidden :
hideNow ( ) ;
break ;
case Visible :
stopShowHideTimer ( ) ;
m_dOpacity = 1.0 ;
if ( ! isVisible ( ) ) show ( ) ; //!!!
break ;
case Showing :
// if the main window got attention while
// showing up then just hide now
if ( shouldHideIfMainWindowGotAttention ( ) )
{
m_eState = Hiding ;
} else {
m_dOpacity + = OPACITY_STEP ;
# ifdef COMPILE_USE_QT4
targetOpacity = isActiveWindow ( ) ? KVI_OPTION_UINT ( KviOption_uintNotifierActiveTransparency ) : KVI_OPTION_UINT ( KviOption_uintNotifierInactiveTransparency ) ;
targetOpacity / = 100 ;
if ( m_dOpacity > = targetOpacity )
{
m_dOpacity = targetOpacity ;
# else
if ( m_dOpacity > = 1.0 )
{
m_dOpacity = 1.0 ;
# endif
m_eState = Visible ;
stopShowHideTimer ( ) ;
startBlinking ( ) ;
startAutoHideTimer ( ) ;
}
if ( ! isVisible ( ) ) show ( ) ; //!!!
if ( m_pLineEdit - > isVisible ( ) ) m_pLineEdit - > hide ( ) ;
# if defined(COMPILE_USE_QT4) && (defined(COMPILE_ON_WINDOWS) || defined(Q_OS_MACX))
setWindowOpacity ( m_dOpacity ) ;
# endif
update ( ) ;
}
break ;
# ifdef COMPILE_USE_QT4
case FocusingOn :
targetOpacity = KVI_OPTION_UINT ( KviOption_uintNotifierActiveTransparency ) ;
targetOpacity / = 100 ;
bIncreasing = targetOpacity > m_dOpacity ;
m_dOpacity + = bIncreasing ?
OPACITY_STEP : - ( OPACITY_STEP ) ;
if ( ( bIncreasing & & ( m_dOpacity > = targetOpacity ) ) | |
( ! bIncreasing & & ( m_dOpacity < = targetOpacity ) )
)
{
m_dOpacity = targetOpacity ;
m_eState = Visible ;
stopShowHideTimer ( ) ;
}
setWindowOpacity ( m_dOpacity ) ;
break ;
case FocusingOff :
targetOpacity = KVI_OPTION_UINT ( KviOption_uintNotifierInactiveTransparency ) ;
targetOpacity / = 100 ;
bIncreasing = targetOpacity > m_dOpacity ;
m_dOpacity + = bIncreasing ? OPACITY_STEP : - ( OPACITY_STEP ) ;
//debug("%f %f %i %i",m_dOpacity,targetOpacity,bIncreasing,(m_dOpacity >= targetOpacity));
if ( ( bIncreasing & & ( m_dOpacity > = targetOpacity ) ) | |
( ! bIncreasing & & ( m_dOpacity < = targetOpacity ) )
)
{
m_dOpacity = targetOpacity ;
m_eState = Visible ;
stopShowHideTimer ( ) ;
}
setWindowOpacity ( m_dOpacity ) ;
break ;
# endif
case Hiding :
m_dOpacity - = OPACITY_STEP ;
# if defined(COMPILE_USE_QT4) && (defined(COMPILE_ON_WINDOWS) || defined(Q_OS_MACX))
setWindowOpacity ( m_dOpacity ) ;
# endif
if ( m_pLineEdit - > isVisible ( ) ) m_pLineEdit - > hide ( ) ;
if ( m_dOpacity < = 0.0 ) hideNow ( ) ;
else update ( ) ;
break ;
}
}
void KviNotifierWindow : : hideNow ( )
{
stopBlinkTimer ( ) ;
stopShowHideTimer ( ) ;
stopAutoHideTimer ( ) ;
m_eState = Hidden ;
m_dOpacity = 0.0 ;
m_tAutoHideAt = 0 ;
if ( m_pLineEdit - > isVisible ( ) ) m_pLineEdit - > hide ( ) ;
hide ( ) ; //if(isVisible())hide();
}
void KviNotifierWindow : : doHide ( bool bDoAnimate )
{
stopAutoHideTimer ( ) ;
switch ( m_eState )
{
case Hiding :
// already hiding up
if ( ! bDoAnimate ) hideNow ( ) ;
return ;
break ;
case Hidden :
// already hidden
if ( isVisible ( ) ) hideNow ( ) ; // !!!
return ;
break ;
case Showing :
// ops.. hiding!
if ( ! bDoAnimate ) hideNow ( ) ;
else {
// continue animating, but hide
m_eState = Hiding ;
}
break ;
case Visible :
stopBlinkTimer ( ) ;
stopShowHideTimer ( ) ;
if ( m_pLineEdit - > isVisible ( ) ) m_pLineEdit - > hide ( ) ;
if ( ( ! bDoAnimate ) | | ( x ( ) ! = m_pWndBorder - > x ( ) ) | | ( y ( ) ! = m_pWndBorder - > y ( ) ) )
{
//debug ("just hide quickly with notifier x() %d and notifier y() % - WBorderx() %d and WBordery() %d and bDoanimate %d",x(),y(),m_pWndBorder->x(),m_pWndBorder->y(),bDoAnimate);
// the user asked to not animate or
// the window has been moved and the animation would suck anyway
// just hide quickly
hideNow ( ) ;
} else {
//debug ("starting hide animation notifier x() %d and notifier y() % - WBorderx() %d and WBordery() %d and bDoanimate %d",x(),y(),m_pWndBorder->x(),m_pWndBorder->y(),bDoAnimate);
m_pShowHideTimer = new TQTimer ( ) ;
connect ( m_pShowHideTimer , TQT_SIGNAL ( timeout ( ) ) , this , TQT_SLOT ( heartbeat ( ) ) ) ;
m_dOpacity = 1.0 - OPACITY_STEP ;
m_eState = Hiding ;
# if defined(COMPILE_USE_QT4) && (defined(COMPILE_ON_WINDOWS) || defined(Q_OS_MACX))
setWindowOpacity ( m_dOpacity ) ;
update ( ) ;
m_pShowHideTimer - > start ( 40 ) ;
# else
update ( ) ;
m_pShowHideTimer - > start ( 100 ) ;
# endif
}
break ;
}
}
void KviNotifierWindow : : showEvent ( TQShowEvent * e )
{
computeRect ( ) ;
setGeometry ( m_wndRect ) ; // w_win = w_wndRect
}
void KviNotifierWindow : : hideEvent ( TQHideEvent * e )
{
if ( m_bCrashShowWorkAround ) return ;
stopBlinkTimer ( ) ;
stopShowHideTimer ( ) ;
stopAutoHideTimer ( ) ;
m_eState = Hidden ; // make sure it's true
m_tAutoHideAt = 0 ; // make sure it's true
markAllMessagesAsHistoric ( ) ;
m_bDisableHideOnMainWindowGotAttention = false ;
}
void KviNotifierWindow : : startBlinking ( )
{
stopBlinkTimer ( ) ;
m_bBlinkOn = false ;
if ( ! KVI_OPTION_BOOL ( KviOption_boolDisableNotifierFlashing ) )
{
m_pBlinkTimer = new TQTimer ( ) ;
connect ( m_pBlinkTimer , TQT_SIGNAL ( timeout ( ) ) , this , TQT_SLOT ( blink ( ) ) ) ;
m_iBlinkCount = 0 ;
m_pBlinkTimer - > start ( m_iBlinkTimeout ) ;
}
}
void KviNotifierWindow : : startAutoHideTimer ( )
{
stopAutoHideTimer ( ) ;
m_tStartedAt = kvi_unixTime ( ) ;
m_qtStartedAt . start ( ) ;
if ( m_tAutoHideAt < = m_tStartedAt ) return ;
int nSecs = m_tAutoHideAt - m_tStartedAt ;
if ( nSecs < 5 ) nSecs = 5 ;
m_pAutoHideTimer = new TQTimer ( ) ;
connect ( m_pAutoHideTimer , TQT_SIGNAL ( timeout ( ) ) , this , TQT_SLOT ( autoHide ( ) ) ) ;
m_pAutoHideTimer - > start ( nSecs * 1000 ) ;
m_pProgressTimer = new TQTimer ( ) ;
connect ( m_pProgressTimer , TQT_SIGNAL ( timeout ( ) ) , this , TQT_SLOT ( progressUpdate ( ) ) ) ;
m_pProgressTimer - > start ( 60 ) ;
}
void KviNotifierWindow : : autoHide ( )
{
m_tAutoHideAt = 0 ;
stopAutoHideTimer ( ) ;
doHide ( true ) ;
}
void KviNotifierWindow : : blink ( )
{
m_iBlinkCount + + ;
m_bBlinkOn = ! m_bBlinkOn ;
if ( m_iBlinkCount > 100 )
{
// stop blinking at a certain point and remain highlighted
m_bBlinkOn = true ;
stopBlinkTimer ( ) ;
} else {
// if the main window got attention while
// showing up then just hide now
if ( shouldHideIfMainWindowGotAttention ( ) )
{
doHide ( false ) ; // don't animate: the background has almost surely changed
return ;
}
}
update ( ) ;
}
void KviNotifierWindow : : markAllMessagesAsHistoric ( )
{
if ( ! m_pWndTabs ) return ;
m_pWndTabs - > markAllMessagesAsHistoric ( ) ;
}
static void blend_images ( TQImage & buffer , TQImage & background , TQImage & foreground , double dValue )
{
for ( int y = 0 ; y < buffer . height ( ) ; y + + )
{
TQRgb * dst = ( TQRgb * ) buffer . scanLine ( y ) ;
TQRgb * end = dst + buffer . width ( ) ;
TQRgb * bkg = ( TQRgb * ) background . scanLine ( y ) ;
TQRgb * fgn = ( TQRgb * ) foreground . scanLine ( y ) ;
double dRemaining = 1.0 - dValue ;
while ( dst < end )
{
* dst = tqRgb (
( int ) ( ( tqRed ( * bkg ) * dRemaining ) + ( tqRed ( * fgn ) * dValue ) ) ,
( int ) ( ( tqGreen ( * bkg ) * dRemaining ) + ( tqGreen ( * fgn ) * dValue ) ) ,
( int ) ( ( tqBlue ( * bkg ) * dRemaining ) + ( tqBlue ( * fgn ) * dValue ) )
) ;
dst + + ;
bkg + + ;
fgn + + ;
}
}
}
void KviNotifierWindow : : paintEvent ( TQPaintEvent * e )
{
/*
if ( m_bBlinkOn )
bitBlt ( & m_pixForeground , TQPoint ( 0 , 0 ) , & m_pixBackgroundHighlighted ) ;
else
bitBlt ( & m_pixForeground , TQPoint ( 0 , 0 ) , & m_pixBackground ) ;
TQPainter p ( & m_pixForeground ) ;
*/
redrawWindow ( ) ;
redrawText ( ) ;
if ( m_dOpacity < 1.0 )
{
TQPainter px ( this ) ;
# if defined(COMPILE_USE_QT4) && (defined(COMPILE_ON_WINDOWS) || defined(Q_OS_MACX))
px . drawPixmap ( 0 , 0 , m_pixForeground ) ;
# else
TQImage temp_image = m_pixForeground . convertToImage ( ) ;
blend_images ( m_imgBuffer , m_imgDesktop , temp_image , m_dOpacity ) ;
px . drawImage ( 0 , 0 , m_imgBuffer ) ;
# endif
px . end ( ) ;
} else {
# ifdef COMPILE_USE_QT4
TQPainter px ( this ) ;
px . drawPixmap ( 0 , 0 , m_pixForeground ) ;
# else
bitBlt ( this , TQPoint ( 0 , 0 ) , & m_pixForeground ) ;
# endif
}
}
void KviNotifierWindow : : redrawText ( )
{
TQPainter p ( & m_pixForeground ) ;
// the current tab
KviNotifierWindowTab * tab = m_pWndTabs - > currentTab ( ) ;
if ( ! tab ) return ;
// it's message list
KviPointerList < KviNotifierMessage > * l = tab - > messageList ( ) ;
if ( ! l ) return ;
if ( l - > isEmpty ( ) ) return ;
// the current message
KviNotifierMessage * cur = tab - > currentMessage ( ) ;
if ( ! cur ) cur = l - > last ( ) ;
// this is useful in several places
KviNotifierMessage * last = l - > last ( ) ;
// make sure that we can loop
int iIdx = l - > tqfindRef ( cur ) ;
if ( iIdx = = - 1 )
{
tab - > setCurrentMessage ( last ) ;
cur = last ;
iIdx = l - > tqfindRef ( cur ) ;
}
int y = m_pWndBody - > textRect ( ) . y ( ) + m_pWndBody - > textRect ( ) . height ( ) ;
if ( m_pLineEdit - > isVisible ( ) ) y - = ( m_pLineEdit - > height ( ) + 4 ) ;
TQColorGroup grp = tqcolorGroup ( ) ;
int idx = iIdx ;
KviNotifierMessage * m = cur ;
while ( m & & ( y > m_pWndBody - > textRect ( ) . y ( ) ) )
{
int iHeight = m - > text ( ) - > height ( ) ;
if ( iHeight < 18 ) iHeight = 18 ;
y - = iHeight ;
if ( m - > historic ( ) )
{
grp . setColor ( TQColorGroup : : Text , m_clrHistoricText ) ;
} else {
if ( m = = last )
grp . setColor ( TQColorGroup : : Text , m_clrCurText ) ;
else {
int iClrIdx = l - > count ( ) - ( idx + 2 ) ;
if ( iClrIdx < 0 ) iClrIdx = 0 ;
else if ( iClrIdx > = NUM_OLD_COLORS ) iClrIdx = ( NUM_OLD_COLORS - 1 ) ;
grp . setColor ( TQColorGroup : : Text , m_clrOldText [ iClrIdx ] ) ;
}
}
int iMaxY = y > m_pWndBody - > textRect ( ) . y ( ) ? y : m_pWndBody - > textRect ( ) . y ( ) ;
TQRect clip ( m_pWndBody - > textRect ( ) . x ( ) + 20 , iMaxY , m_pWndBody - > textRect ( ) . width ( ) - 20 , iHeight ) ;
m - > text ( ) - > draw ( & p , m_pWndBody - > textRect ( ) . x ( ) + 20 , y , clip , grp ) ; //
if ( y > m_pWndBody - > textRect ( ) . y ( ) )
{
if ( m - > image ( ) )
p . drawPixmap ( m_pWndBody - > textRect ( ) . x ( ) + 1 , y + 1 , * ( m - > image ( ) ) , 0 , 0 , 16 , 16 ) ;
}
m = l - > prev ( ) ;
idx - - ;
}
p . setPen ( TQPen ( m_clrTitle ) ) ;
p . setFont ( * m_pTitleFont ) ;
TQString title ;
KviTQString : : sprintf ( title , " [%d/%d] " , iIdx + 1 , l - > count ( ) ) ;
if ( tab - > window ( ) )
{
title + = " " ;
title + = tab - > window ( ) - > plainTextCaption ( ) ;
}
p . drawText ( m_pWndBorder - > titleRect ( ) , TQt : : AlignLeft | TQt : : SingleLine , title ) ;
p . end ( ) ;
}
void KviNotifierWindow : : mouseMoveEvent ( TQMouseEvent * e )
{
//debug ("move on x,y: %d,%d", e->pos().x(), e->pos().y());
if ( ! m_bLeftButtonIsPressed ) {
if ( checkResizing ( e - > pos ( ) ) ) goto sartelo ;
/* ### MOUSE-MOVE-EVENT -> m_pWndBorder ### */
if ( m_pWndBorder - > captionRect ( ) . tqcontains ( e - > pos ( ) ) ) {
if ( m_pWndBorder - > closeRect ( ) . tqcontains ( e - > pos ( ) ) ) {
m_pWndBorder - > setCloseIcon ( WDG_ICON_OVER ) ;
} else {
m_pWndBorder - > setCloseIcon ( WDG_ICON_OUT ) ;
}
goto sartelo ;
}
if ( m_pWndTabs - > currentTab ( ) )
{
/* ### MOUSE-MOVE-EVENT -> m_pWndTabs ### */
if ( m_pWndTabs - > rect ( ) . tqcontains ( e - > pos ( ) ) ) {
m_pWndTabs - > mouseMoveEvent ( e ) ;
goto sartelo ;
}
/* ### MOUSE-MOVE-EVENT -> m_pWndBody ### */
if ( m_pWndBody - > rect ( ) . tqcontains ( e - > pos ( ) ) ) {
if ( m_pWndBody - > rctWriteIcon ( ) . tqcontains ( e - > pos ( ) ) ) {
m_pWndBody - > setWriteIcon ( WDG_ICON_ON ) ;
} else {
m_pWndBody - > setWriteIcon ( WDG_ICON_OFF ) ;
}
goto sartelo ;
}
}
/* ### END ### */
sartelo :
update ( ) ;
}
if ( m_bDragging ) {
setCursor ( TQt : : SizeAllCursor ) ;
int w = m_wndRect . width ( ) ;
int h = m_wndRect . height ( ) ;
m_wndRect . setX ( m_pntPos . x ( ) + cursor ( ) . pos ( ) . x ( ) - m_pntDrag . x ( ) ) ;
m_wndRect . setY ( m_pntPos . y ( ) + cursor ( ) . pos ( ) . y ( ) - m_pntDrag . y ( ) ) ;
m_wndRect . setWidth ( w ) ;
m_wndRect . setHeight ( h ) ;
setGeometry ( m_wndRect ) ;
return ;
} else if ( m_bResizing ) {
resize ( e - > pos ( ) ) ;
}
}
void KviNotifierWindow : : mousePressEvent ( TQMouseEvent * e )
{
// stop blinking first of all :)
bool bWasBlinkOn = m_bBlinkOn ;
m_bBlinkOn = false ;
stopBlinkTimer ( ) ;
m_tAutoHideAt = 0 ;
stopAutoHideTimer ( ) ;
setActiveWindow ( ) ;
setFocus ( ) ;
m_pntClick = e - > pos ( ) ;
if ( e - > button ( ) = = Qt : : RightButton )
{
contextPopup ( mapToGlobal ( e - > pos ( ) ) ) ;
return ;
} else if ( e - > button ( ) = = Qt : : LeftButton ) {
m_bLeftButtonIsPressed = true ;
}
if ( checkResizing ( m_pntClick ) ) goto sartelo ;
if ( m_pWndTabs - > rect ( ) . tqcontains ( e - > pos ( ) ) )
{
m_pWndTabs - > mousePressEvent ( e ) ;
goto sartelo ;
}
if ( m_pWndBorder - > captionRect ( ) . tqcontains ( e - > pos ( ) ) ) {
//debug ("Clicked on m_pWndBorder->rect()");
if ( m_pWndBorder - > closeRect ( ) . tqcontains ( e - > pos ( ) ) ) {
//debug ("\tClicked on m_pWndBorder->closeRect()");
m_bCloseDown = true ;
m_pWndBorder - > setCloseIcon ( WDG_ICON_CLICKED ) ;
goto sartelo ;
}
if ( ! m_bResizing ) {
m_bDragging = true ;
m_pntDrag = cursor ( ) . pos ( ) ;
m_pntPos = pos ( ) ;
goto sartelo ;
}
}
//debug ("x,y: %d,%d - width,height: %d,%d", m_pWndBorder->rect().x(),m_pWndBorder->rect().y(),m_pWndBorder->rect().width(),m_pWndBorder->rect().height());
if ( m_pWndBorder - > rect ( ) . tqcontains ( e - > pos ( ) ) ) {
if ( m_pWndTabs - > currentTab ( ) )
{
//debug ("Clicked on m_pWndBody->textRect()");
if ( m_pWndBody - > rctWriteIcon ( ) . tqcontains ( e - > pos ( ) ) )
{
m_pWndBody - > setWriteIcon ( WDG_ICON_CLICKED ) ;
showLineEdit ( ! ( m_pLineEdit - > isVisible ( ) ) ) ;
}
if ( m_pWndBody - > rctPrevIcon ( ) . tqcontains ( e - > pos ( ) ) & & m_pWndBody - > prevIconState ( ) ! = WDG_ICON_OFF )
{
m_bPrevDown = true ;
m_pWndBody - > setPrevIcon ( WDG_ICON_CLICKED ) ;
prevButtonClicked ( ) ;
}
if ( m_pWndBody - > rctNextIcon ( ) . tqcontains ( e - > pos ( ) ) & & m_pWndBody - > nextIconState ( ) ! = WDG_ICON_OFF )
{
m_bNextDown = true ;
m_pWndBody - > setNextIcon ( WDG_ICON_CLICKED ) ;
nextButtonClicked ( ) ;
}
}
goto sartelo ;
}
if ( bWasBlinkOn ) goto sartelo ; else return ;
sartelo :
update ( ) ;
}
void KviNotifierWindow : : mouseReleaseEvent ( TQMouseEvent * e )
{
m_bWriteDown = false ;
m_bNextDown = false ;
m_bPrevDown = false ;
m_bCloseDown = false ;
m_bLeftButtonIsPressed = false ;
m_bResizing = false ;
//m_pWndBody->setWriteIcon(WDG_ICON_ON);
m_pWndBody - > setNextIcon ( WDG_ICON_ON ) ;
m_pWndBody - > setPrevIcon ( WDG_ICON_ON ) ;
m_pWndTabs - > setCloseTabIcon ( WDG_ICON_OFF ) ;
if ( m_bDragging )
{
m_bDragging = false ;
if ( TQApplication : : overrideCursor ( ) ) TQApplication : : restoreOverrideCursor ( ) ;
return ;
}
if ( m_pWndBorder - > captionRect ( ) . tqcontains ( e - > pos ( ) ) ) {
if ( m_pWndBorder - > closeRect ( ) . tqcontains ( e - > pos ( ) ) ) {
//debug ("hide now from release event");
hideNow ( ) ;
} else {
update ( ) ;
}
}
if ( m_pWndTabs - > rect ( ) . tqcontains ( e - > pos ( ) ) )
{
m_pWndTabs - > mouseReleaseEvent ( e ) ;
}
setCursor ( - 1 ) ;
}
void KviNotifierWindow : : mouseDoubleClickEvent ( TQMouseEvent * e )
{
if ( ! m_pWndBody - > textRect ( ) . tqcontains ( e - > pos ( ) ) )
{
TQWidget : : mouseDoubleClickEvent ( e ) ;
return ;
}
KviNotifierWindowTab * tab = m_pWndTabs - > currentTab ( ) ;
if ( ! tab ) return ;
if ( ! tab - > window ( ) ) return ;
hideNow ( ) ;
delayedRaise ( tab - > window ( ) ) ;
}
void KviNotifierWindow : : keyPressEvent ( TQKeyEvent * e )
{
if ( e - > key ( ) = = TQt : : Key_Shift ) {
m_bKeyShiftPressed = true ;
return ;
}
if ( e - > key ( ) = = TQt : : Key_Left & & m_bKeyShiftPressed ) {
m_pWndTabs - > prev ( ) ;
return ;
}
if ( e - > key ( ) = = TQt : : Key_Right & & m_bKeyShiftPressed ) {
m_pWndTabs - > next ( ) ;
return ;
}
if ( e - > key ( ) = = TQt : : Key_Escape ) {
hideNow ( ) ;
return ;
}
}
void KviNotifierWindow : : keyReleaseEvent ( TQKeyEvent * e )
{
if ( e - > key ( ) = = TQt : : Key_Shift ) {
m_bKeyShiftPressed = false ;
}
}
void KviNotifierWindow : : delayedRaise ( KviWindow * pWnd )
{
m_pWindowToRaise = pWnd ;
TQTimer : : singleShot ( 0 , this , TQT_SLOT ( delayedRaiseSlot ( ) ) ) ;
}
void KviNotifierWindow : : delayedRaiseSlot ( )
{
if ( ! m_pWindowToRaise ) return ;
if ( ! g_pApp - > windowExists ( m_pWindowToRaise ) ) return ;
if ( m_pWindowToRaise - > mdiParent ( ) )
{
if ( ! m_pWindowToRaise - > frame ( ) - > isVisible ( ) )
m_pWindowToRaise - > frame ( ) - > show ( ) ;
m_pWindowToRaise - > frame ( ) - > raise ( ) ;
//((TQWidget *)(m_pWindowToRaise->frame()))->setActiveWindow();
m_pWindowToRaise - > frame ( ) - > setFocus ( ) ;
}
m_pWindowToRaise - > delayedAutoRaise ( ) ;
}
bool KviNotifierWindow : : checkResizing ( TQPoint e )
{
if ( e . y ( ) < WDG_BORDER_THICKNESS ) {
if ( e . x ( ) < WDG_BORDER_THICKNESS ) {
//// UP LEFT CORNER ////
setCursor ( TQt : : SizeFDiagCursor ) ;
if ( m_bLeftButtonIsPressed ) {
m_bResizing = true ;
m_whereResizing = WDG_UPSX ;
}
} else if ( e . x ( ) > ( size ( ) . width ( ) - WDG_BORDER_THICKNESS ) ) {
//// UP RIGHT CORNER ////
setCursor ( TQt : : SizeBDiagCursor ) ;
if ( m_bLeftButtonIsPressed ) {
m_bResizing = true ;
m_whereResizing = WDG_UPDX ;
}
} else {
//// UP SIDE ////
setCursor ( TQt : : SizeVerCursor ) ;
if ( m_bLeftButtonIsPressed ) {
m_bResizing = true ;
m_whereResizing = WDG_UP ;
} }
} else if ( e . y ( ) > ( size ( ) . height ( ) - WDG_BORDER_THICKNESS ) ) {
if ( e . x ( ) < WDG_BORDER_THICKNESS ) {
//// DOWN LEFT CORNER ////
setCursor ( TQt : : SizeBDiagCursor ) ;
if ( m_bLeftButtonIsPressed ) {
m_bResizing = true ;
m_whereResizing = WDG_DWNSX ;
}
} else if ( e . x ( ) > ( size ( ) . width ( ) - WDG_BORDER_THICKNESS ) ) {
//// DOWN RIGHT CORNER ////
setCursor ( TQt : : SizeFDiagCursor ) ;
if ( m_bLeftButtonIsPressed ) {
m_bResizing = true ;
m_whereResizing = WDG_DWNDX ;
}
} else {
//// DOWN SIDE ////
setCursor ( TQt : : SizeVerCursor ) ;
if ( m_bLeftButtonIsPressed ) {
m_bResizing = true ;
m_whereResizing = WDG_DWN ;
}
}
} else {
if ( e . x ( ) < WDG_BORDER_THICKNESS ) {
//// LEFT SIZE ////
setCursor ( TQt : : SizeHorCursor ) ;
if ( m_bLeftButtonIsPressed ) {
m_bResizing = true ;
m_whereResizing = WDG_SX ;
}
} else if ( e . x ( ) > ( size ( ) . width ( ) - WDG_BORDER_THICKNESS ) ) {
//// RIGHT SIZE ////
setCursor ( TQt : : SizeHorCursor ) ;
if ( m_bLeftButtonIsPressed ) {
m_bResizing = true ;
m_whereResizing = WDG_DX ;
}
} else {
//// ELSEWHERE ////
m_whereResizing = 0 ;
m_bResizing = false ;
setCursor ( - 1 ) ;
}
}
return m_bResizing ;
} ;
void KviNotifierWindow : : resize ( TQPoint p , bool up )
{
//TQPoint aux = mapToGlobal(p);
if ( m_whereResizing = = WDG_UPSX | | m_whereResizing = = WDG_SX | | m_whereResizing = = WDG_DWNSX ) {
if ( ( x ( ) + width ( ) - cursor ( ) . pos ( ) . x ( ) ) < WDG_MIN_WIDTH )
m_wndRect . setLeft ( x ( ) + width ( ) - WDG_MIN_WIDTH ) ;
else
m_wndRect . setLeft ( cursor ( ) . pos ( ) . x ( ) ) ;
}
if ( m_whereResizing = = WDG_UPSX | | m_whereResizing = = WDG_UP | | m_whereResizing = = WDG_UPDX ) {
if ( y ( ) + height ( ) - cursor ( ) . pos ( ) . y ( ) < WDG_MIN_HEIGHT )
m_wndRect . setTop ( y ( ) + height ( ) - WDG_MIN_HEIGHT ) ;
else
m_wndRect . setTop ( cursor ( ) . pos ( ) . y ( ) ) ;
}
if ( m_whereResizing = = WDG_DX | | m_whereResizing = = WDG_UPDX | | m_whereResizing = = WDG_DWNDX ) {
if ( ( cursor ( ) . pos ( ) . x ( ) - x ( ) ) > WDG_MIN_WIDTH )
m_wndRect . setRight ( cursor ( ) . pos ( ) . x ( ) ) ;
else
m_wndRect . setRight ( x ( ) + WDG_MIN_WIDTH ) ;
}
if ( m_whereResizing = = WDG_DWN | | m_whereResizing = = WDG_DWNDX | | m_whereResizing = = WDG_DWNSX ) {
if ( ( cursor ( ) . pos ( ) . y ( ) - y ( ) ) > WDG_MIN_HEIGHT )
m_wndRect . setBottom ( cursor ( ) . pos ( ) . y ( ) ) ;
else
m_wndRect . setBottom ( y ( ) + WDG_MIN_HEIGHT ) ;
}
showLineEdit ( m_pLineEdit - > isVisible ( ) ) ;
setGeometry ( m_wndRect ) ;
}
void KviNotifierWindow : : redrawWindow ( )
{
if ( m_pixBackground . size ( ) ! = m_wndRect . size ( ) )
{
// Redraw only if size was modified..
m_pixBackground . resize ( m_wndRect . size ( ) ) ;
m_pixForeground . resize ( m_wndRect . size ( ) ) ;
m_pixBackgroundHighlighted . resize ( m_wndRect . size ( ) ) ;
m_pWndBorder - > resize ( m_wndRect . size ( ) ) ;
m_pWndTabs - > setWidth ( m_pWndBorder - > tabsRect ( ) . width ( ) ) ;
m_pWndBody - > resize ( m_pWndBorder - > bodyRect ( ) ) ;
m_pProgressBar - > setHeight ( m_pWndBorder - > bodyRect ( ) . height ( ) + m_pWndBorder - > tabsRect ( ) . height ( ) ) ;
}
TQPainter paint ;
if ( m_bBlinkOn )
{
m_pWndBorder - > touch ( ) ;
m_pWndTabs - > touch ( ) ;
m_pWndBody - > touch ( ) ;
paint . begin ( & m_pixBackgroundHighlighted ) ;
m_pWndBorder - > draw ( & paint , true ) ;
m_pWndTabs - > draw ( & paint ) ;
m_pWndBody - > draw ( & paint ) ;
m_pProgressBar - > draw ( & paint ) ;
paint . end ( ) ;
bitBlt ( & m_pixForeground , 0 , 0 , & m_pixBackgroundHighlighted ) ;
m_pWndBorder - > touch ( ) ;
m_pWndTabs - > touch ( ) ;
m_pWndBody - > touch ( ) ;
} else {
paint . begin ( & m_pixBackground ) ;
m_pWndBorder - > draw ( & paint ) ;
m_pWndTabs - > draw ( & paint ) ;
m_pWndBody - > draw ( & paint ) ;
m_pProgressBar - > draw ( & paint ) ;
paint . end ( ) ;
bitBlt ( & m_pixForeground , 0 , 0 , & m_pixBackground ) ;
}
}
inline void KviNotifierWindow : : setCursor ( int cur ) {
if ( m_cursor . tqshape ( ) ! = cur ) {
if ( TQApplication : : overrideCursor ( ) ) TQApplication : : restoreOverrideCursor ( ) ;
m_cursor . setShape ( ( Qt : : CursorShape ) cur ) ;
TQApplication : : setOverrideCursor ( m_cursor ) ;
} else if ( cur = = - 1 )
if ( TQApplication : : overrideCursor ( ) ) TQApplication : : restoreOverrideCursor ( ) ;
}
void KviNotifierWindow : : enterEvent ( TQEvent * e )
{
# ifdef COMPILE_USE_QT4
if ( ! m_pShowHideTimer ) {
m_pShowHideTimer = new TQTimer ( ) ;
connect ( m_pShowHideTimer , TQT_SIGNAL ( timeout ( ) ) , this , TQT_SLOT ( heartbeat ( ) ) ) ;
}
m_eState = FocusingOn ;
m_pShowHideTimer - > start ( 40 ) ;
# endif
}
void KviNotifierWindow : : leaveEvent ( TQEvent * e )
{
// Leaving the widget area, restore default cursor
m_pWndBorder - > resetIcons ( ) ;
m_pWndTabs - > resetIcons ( ) ;
if ( ! m_bResizing )
setCursor ( - 1 ) ;
# ifdef COMPILE_USE_QT4
if ( ! m_pShowHideTimer ) {
m_pShowHideTimer = new TQTimer ( ) ;
connect ( m_pShowHideTimer , TQT_SIGNAL ( timeout ( ) ) , this , TQT_SLOT ( heartbeat ( ) ) ) ;
}
m_eState = FocusingOff ;
m_pShowHideTimer - > start ( 40 ) ;
# endif
}
void KviNotifierWindow : : contextPopup ( const TQPoint & pos )
{
if ( ! m_pContextPopup )
{
m_pContextPopup = new TQPopupMenu ( this ) ;
connect ( m_pContextPopup , TQT_SIGNAL ( aboutToShow ( ) ) , this , TQT_SLOT ( fillContextPopup ( ) ) ) ;
m_pDisablePopup = new TQPopupMenu ( this ) ;
}
m_pContextPopup - > popup ( pos ) ;
}
void KviNotifierWindow : : fillContextPopup ( )
{
m_pContextPopup - > clear ( ) ;
m_pContextPopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_CLOSE ) ) , __tr2qs_ctx ( " Hide " , " notifier " ) , this , TQT_SLOT ( hideNow ( ) ) ) ;
m_pContextPopup - > insertSeparator ( ) ;
m_pDisablePopup - > clear ( ) ;
m_pDisablePopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_TIME ) ) , __tr2qs_ctx ( " 1 Minute " , " notifier " ) , this , TQT_SLOT ( disableFor1Minute ( ) ) ) ;
m_pDisablePopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_TIME ) ) , __tr2qs_ctx ( " 5 Minutes " , " notifier " ) , this , TQT_SLOT ( disableFor5Minutes ( ) ) ) ;
m_pDisablePopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_TIME ) ) , __tr2qs_ctx ( " 15 Minutes " , " notifier " ) , this , TQT_SLOT ( disableFor15Minutes ( ) ) ) ;
m_pDisablePopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_TIME ) ) , __tr2qs_ctx ( " 30 Minutes " , " notifier " ) , this , TQT_SLOT ( disableFor30Minutes ( ) ) ) ;
m_pDisablePopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_TIME ) ) , __tr2qs_ctx ( " 1 Hour " , " notifier " ) , this , TQT_SLOT ( disableFor60Minutes ( ) ) ) ;
m_pDisablePopup - > insertSeparator ( ) ;
m_pDisablePopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_TQUIT ) ) , __tr2qs_ctx ( " Until KVIrc is Restarted " , " notifier " ) , this , TQT_SLOT ( disableUntilKVIrcRestarted ( ) ) ) ;
m_pDisablePopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_TQUIT ) ) , __tr2qs_ctx ( " Permanently (Until Explicitly Enabled) " , " notifier " ) , this , TQT_SLOT ( disablePermanently ( ) ) ) ;
m_pContextPopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_TQUIT ) ) , __tr2qs_ctx ( " Disable " , " notifier " ) , m_pDisablePopup ) ;
}
void KviNotifierWindow : : disableFor15Minutes ( )
{
kvi_time_t tNow = kvi_unixTime ( ) ;
g_tNotifierDisabledUntil = tNow + ( 60 * 15 ) ;
hideNow ( ) ;
}
void KviNotifierWindow : : disableFor5Minutes ( )
{
kvi_time_t tNow = kvi_unixTime ( ) ;
g_tNotifierDisabledUntil = tNow + ( 60 * 5 ) ;
hideNow ( ) ;
}
void KviNotifierWindow : : disableFor1Minute ( )
{
kvi_time_t tNow = kvi_unixTime ( ) ;
g_tNotifierDisabledUntil = tNow + 60 ;
hideNow ( ) ;
}
void KviNotifierWindow : : disableFor30Minutes ( )
{
kvi_time_t tNow = kvi_unixTime ( ) ;
g_tNotifierDisabledUntil = tNow + ( 60 * 30 ) ;
hideNow ( ) ;
}
void KviNotifierWindow : : disableFor60Minutes ( )
{
kvi_time_t tNow = kvi_unixTime ( ) ;
g_tNotifierDisabledUntil = tNow + ( 60 * 60 ) ;
hideNow ( ) ;
}
void KviNotifierWindow : : disableUntilKVIrcRestarted ( )
{
kvi_time_t tNow = kvi_unixTime ( ) ;
// in fact we just disable for one year
g_tNotifierDisabledUntil = tNow + ( 3600 * 24 * 360 ) ; // one year :D
// this will NOT work if the module is forcibly unloaded with /notifier.unload
// but the user should never do it :D
hideNow ( ) ;
}
void KviNotifierWindow : : disablePermanently ( )
{
KVI_OPTION_BOOL ( KviOption_boolForciblyDisableNotifier ) = true ;
hideNow ( ) ;
}
void KviNotifierWindow : : wheelEvent ( TQWheelEvent * e )
{
if ( e - > delta ( ) > 0 ) prevButtonClicked ( ) ;
else nextButtonClicked ( ) ;
}
void KviNotifierWindow : : prevButtonClicked ( )
{
KviNotifierWindowTab * tab = m_pWndTabs - > currentTab ( ) ;
if ( ! tab ) return ;
tab - > setPrevMessageAsCurrent ( ) ;
update ( ) ;
}
void KviNotifierWindow : : nextButtonClicked ( )
{
KviNotifierWindowTab * tab = m_pWndTabs - > currentTab ( ) ;
if ( ! tab ) return ;
tab - > setNextMessageAsCurrent ( ) ;
update ( ) ;
}
void KviNotifierWindow : : showLineEdit ( bool bShow )
{
if ( bShow )
{
//if(m_pLineEdit->isVisible())return;
if ( ! m_pWndTabs - > currentMessage ( ) ) return ;
if ( ! m_pWndTabs - > currentTab ( ) - > window ( ) ) return ;
TQToolTip : : remove ( m_pLineEdit ) ;
TQString tip = __tr2qs_ctx ( " Write text or commands to window " , " notifier " ) ;
tip + = " \" " ;
tip + = m_pWndTabs - > currentTab ( ) - > window ( ) - > plainTextCaption ( ) ;
tip + = " \" " ;
TQToolTip : : add ( m_pLineEdit , tip ) ;
m_pLineEdit - > setGeometry ( m_pWndBody - > textRect ( ) . x ( ) , m_pWndBody - > textRect ( ) . y ( ) + m_pWndBody - > textRect ( ) . height ( ) - m_iInputHeight , m_pWndBody - > textRect ( ) . width ( ) , m_iInputHeight ) ;
m_pLineEdit - > show ( ) ;
m_pLineEdit - > setFocus ( ) ;
redrawWindow ( ) ;
setActiveWindow ( ) ;
} else {
if ( ! m_pLineEdit - > isVisible ( ) ) return ;
m_pLineEdit - > hide ( ) ;
setFocus ( ) ;
KviNotifierWindowTab * tab = m_pWndTabs - > currentTab ( ) ;
if ( tab ) tab - > setLastMessageAsCurrent ( ) ;
update ( ) ;
}
}
bool KviNotifierWindow : : eventFilter ( TQObject * pEdit , TQEvent * e )
{
if ( pEdit ! = ( TQObject * ) m_pLineEdit ) return false ; // huh ?
if ( ! m_pLineEdit - > isVisible ( ) ) return false ;
if ( e - > type ( ) = = TQEvent : : MouseButtonPress )
{
bool bWasBlinkOn = m_bBlinkOn ;
m_bBlinkOn = false ;
m_tAutoHideAt = 0 ;
stopAutoHideTimer ( ) ;
stopBlinkTimer ( ) ;
setActiveWindow ( ) ;
m_pLineEdit - > setFocus ( ) ;
if ( bWasBlinkOn ) update ( ) ;
return true ;
}
if ( e - > type ( ) = = TQEvent : : KeyPress )
{
if ( ( ( TQKeyEvent * ) e ) - > key ( ) = = TQt : : Key_Escape )
{
hideNow ( ) ;
return true ;
}
}
return false ;
}
void KviNotifierWindow : : returnPressed ( )
{
if ( ! m_pLineEdit - > isVisible ( ) ) return ;
KviNotifierWindowTab * tab = m_pWndTabs - > currentTab ( ) ;
if ( ! tab ) return ;
if ( ! tab - > currentMessage ( ) ) return ;
if ( ! tab - > window ( ) ) return ;
TQString txt = m_pLineEdit - > text ( ) ;
if ( txt . isEmpty ( ) ) return ;
TQString html = txt ;
html . tqreplace ( " < " , " < " ) ;
html . tqreplace ( " > " , " > " ) ;
KviStr tmp ( KviStr : : Format , " %d " , KVI_SMALLICON_OWNPRIVMSG ) ;
addMessage ( tab - > window ( ) , tmp . ptr ( ) , html , 0 ) ; //m_pCurrentFocusedWindowTab on place of m_pCurrentMessage->window()
m_pLineEdit - > setText ( " " ) ;
KviUserInput : : parse ( txt , tab - > window ( ) , TQString ( ) , 1 ) ;
}
void KviNotifierWindow : : progressUpdate ( )
{
double dProgress = m_qtStartedAt . elapsed ( ) / ( m_tAutoHideAt - m_tStartedAt ) ;
dProgress / = 1000 ;
m_pProgressBar - > setProgress ( dProgress ) ;
TQPainter p ( this ) ;
m_pProgressBar - > draw ( & p ) ;
}
# include "m_notifierwindow.moc"