//=============================================================================
//
// File : kvi_window.cpp
// Creation date : Tue Jul 6 1999 14:52:11 by Szymon Stefanek
//
// This file is part of the KVirc irc client distribution
// Copyright (C) 1999-2007 Szymon Stefanek (pragma at kvirc dot net)
//
// This program is FREE software. You can redistribute it and/or
// modify it under the terms 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.
//
//=============================================================================
# define __KVIRC__
# define KVI_WINDOW_MIN_WIDTH 100
# define KVI_WINDOW_MIN_HEIGHT 100
# define _KVI_WINDOW_CPP_
# define _KVI_DEBUG_CHECK_RANGE_
# include "kvi_debug.h"
# include "kvi_app.h"
# include "kvi_window.h"
# include "kvi_frame.h"
# include "kvi_taskbar.h"
# include "kvi_iconmanager.h"
# include "kvi_mdichild.h"
# include "kvi_locale.h"
# include "kvi_ircview.h"
# include "kvi_out.h"
# include "kvi_malloc.h"
# include "kvi_input.h"
# include "kvi_fileutils.h"
# include "kvi_options.h"
# include "kvi_config.h"
# include "kvi_irccontext.h"
# include "kvi_console.h"
# include "kvi_ircconnectionserverinfo.h"
# include "kvi_mirccntrl.h"
# include "kvi_toolwindows_container.h"
# include "kvi_styled_controls.h"
# include "kvi_kvs_script.h"
# include <tqpixmap.h>
# include "kvi_tal_popupmenu.h"
# include <tqcursor.h>
# include <tqtimer.h>
# include <tqsplitter.h>
# include <tqmetaobject.h>
# include <tqdatetime.h>
# include <tqtextcodec.h>
# include <tqevent.h>
// it looks they can't decide :D
# ifdef COMPILE_USE_QT4
# include <TQPushButton>
# include <tqdesktopwidget.h>
# else
# include <tqobjectlist.h>
# endif
# include <tqvariant.h>
# include <tqtoolbutton.h>
# include "kvi_tal_tooltip.h"
# include <tqmessagebox.h>
# ifdef COMPILE_CRYPT_SUPPORT
# include "kvi_crypt.h"
# include "kvi_cryptcontroller.h"
# endif
# ifdef COMPILE_KDE_SUPPORT
# include <twin.h>
# include <tdeversion.h>
# endif
# ifdef COMPILE_ON_WINDOWS
# include <windows.h>
# endif
KVIRC_API KviWindow * g_pActiveWindow = 0 ;
static KviTalPopupMenu * g_pMdiWindowSystemMainPopup = 0 ;
static KviTalPopupMenu * g_pMdiWindowSystemTextEncodingPopup = 0 ;
static KviTalPopupMenu * g_pMdiWindowSystemTextEncodingPopupStandard = 0 ;
static KviTalPopupMenu * g_pMdiWindowSystemTextEncodingPopupSmart = 0 ;
static KviTalPopupMenu * g_pMdiWindowSystemTextEncodingPopupSmartUtf8 = 0 ;
unsigned long int g_uUniqueWindowId = 1 ;
// FIXME: #warning "Mouse wheel support"
KviWindow : : KviWindow ( int type , KviFrame * lpFrm , const TQString & name , KviConsole * lpConsole )
: TQWidget ( 0 )
{
m_uId = g_uUniqueWindowId ;
g_uUniqueWindowId + + ;
// FIXME: REMOVE THIS
setName ( name ) ;
// END FIXME
m_szName = name ;
g_pApp - > registerWindow ( this ) ;
m_iType = type ;
m_pFocusHandler = 0 ;
m_pFrm = lpFrm ; // FIXME: Should disappear!
m_pIrcView = 0 ;
m_pInput = 0 ;
m_pSplitter = 0 ;
m_pButtonBox = 0 ;
m_pConsole = lpConsole ;
m_pContext = lpConsole ? lpConsole - > context ( ) : 0 ;
m_pLastFocusedChild = 0 ;
m_pTextCodec = 0 ; // will be set by loadProperties
m_pTextEncodingButton = 0 ;
m_pHideToolsButton = 0 ;
// m_pEditorsContainer = 0;
# ifdef COMPILE_CRYPT_SUPPORT
m_pCryptControllerButton = 0 ;
m_pCryptController = 0 ;
m_pCryptSessionInfo = 0 ;
# endif
m_pAccel = 0 ;
m_pTaskBarItem = 0 ;
setMinimumSize ( KVI_WINDOW_MIN_WIDTH , KVI_WINDOW_MIN_HEIGHT ) ;
# ifdef COMPILE_USE_QT4
//setAutoFillBackground(false);
setFocusPolicy ( TTQ_StrongFocus ) ;
# else
setBackgroundMode ( NoBackground ) ;
setFocusPolicy ( TQ_StrongFocus ) ;
# endif
connect ( g_pApp , TQT_SIGNAL ( reloadImages ( ) ) , this , TQT_SLOT ( reloadImages ( ) ) ) ;
}
KviWindow : : ~ KviWindow ( )
{
//g_pFrame->childWindowDestroyed(this);
destroyTaskBarItem ( ) ;
g_pApp - > unregisterWindow ( this ) ;
if ( g_pApp - > windowCount ( ) = = 0 )
{
// this is the last window!
if ( g_pMdiWindowSystemMainPopup )
delete g_pMdiWindowSystemMainPopup ;
if ( g_pMdiWindowSystemTextEncodingPopup )
delete g_pMdiWindowSystemTextEncodingPopup ;
if ( g_pMdiWindowSystemTextEncodingPopupStandard )
delete g_pMdiWindowSystemTextEncodingPopupStandard ;
if ( g_pMdiWindowSystemTextEncodingPopupSmart )
delete g_pMdiWindowSystemTextEncodingPopupSmart ;
if ( g_pMdiWindowSystemTextEncodingPopupSmartUtf8 )
delete g_pMdiWindowSystemTextEncodingPopupSmartUtf8 ;
}
# ifdef COMPILE_CRYPT_SUPPORT
if ( m_pCryptSessionInfo )
KviCryptController : : destroyCryptSessionInfo ( & m_pCryptSessionInfo ) ;
# endif
}
void KviWindow : : setWindowName ( const TQString & szName )
{
m_szName = szName ;
emit windowNameChanged ( ) ;
}
void KviWindow : : toggleButtonContainer ( )
{
TQFrame * pContainer = buttonContainer ( ) ;
if ( pContainer )
{
pContainer - > setHidden ( ! pContainer - > isHidden ( ) ) ;
}
}
void KviWindow : : setName ( const char * name )
{
m_szName = name ;
TQWidget : : setName ( name ) ;
}
KviIrcConnection * KviWindow : : connection ( )
{
return m_pContext ? m_pContext - > connection ( ) : 0 ;
}
void KviWindow : : reloadImages ( )
{
updateIcon ( ) ;
}
bool KviWindow : : hasAttention ( )
{
if ( ( ( TQApplication * ) g_pApp ) - > activeWindow ( ) = = 0 ) return false ; // no application window has the focus atm
if ( mdiParent ( ) )
{
if ( frame ( ) - > isActiveWindow ( ) ) return true ;
// This frame is not the active window but the
// active window still belongs to KVIrc.
// When the active window is derived from TQDialog
// then it is probably a KVIrc's option dialog
// or something similar.
// In this case we assume that the user has the
// KVIrc window just below and can see it.
// Handle the special case of the dialogs then
TQWidget * w = TQT_TQWIDGET ( ( ( TQApplication * ) g_pApp ) - > activeWindow ( ) ) ;
if ( w - > inherits ( TQDIALOG_OBJECT_NAME_STRING ) )
{
// but make sure that the frame is visible at all!
if ( ! frame ( ) - > isVisible ( ) ) return false ;
return true ;
}
// any other class is so unfrequent that we ignore it
} else {
// when the window is undocked, instead
// it is likely to be covered by KVIrc or other windows...
if ( isActiveWindow ( ) ) return true ;
}
return false ;
}
void KviWindow : : demandAttention ( )
{
if ( mdiParent ( ) )
{
if ( frame ( ) - > isActiveWindow ( ) ) return ;
# ifdef COMPILE_ON_WINDOWS
FLASHWINFO fwi ;
fwi . cbSize = sizeof ( fwi ) ;
fwi . hwnd = ( HWND ) ( frame ( ) - > winId ( ) ) ;
fwi . dwFlags = FLASHW_TRAY | FLASHW_TIMERNOFG ;
fwi . uCount = 20 ;
fwi . dwTimeout = 500 ;
FlashWindowEx ( & fwi ) ;
# else
# ifdef COMPILE_KDE_SUPPORT
# if (TDE_VERSION_MAJOR >= 3) && (TDE_VERSION_MINOR >= 2)
KWin : : demandAttention ( frame ( ) - > winId ( ) , true ) ;
# endif
# endif
# endif
} else {
if ( isActiveWindow ( ) ) return ;
# ifdef COMPILE_ON_WINDOWS
FLASHWINFO fwi ;
fwi . cbSize = sizeof ( fwi ) ;
fwi . hwnd = ( HWND ) winId ( ) ;
fwi . dwFlags = FLASHW_TRAY | FLASHW_TIMERNOFG ;
fwi . uCount = 20 ;
fwi . dwTimeout = 500 ;
FlashWindowEx ( & fwi ) ;
# else
# ifdef COMPILE_KDE_SUPPORT
# if (TDE_VERSION_MAJOR >= 3) && (TDE_VERSION_MINOR >= 2)
KWin : : demandAttention ( winId ( ) , true ) ;
# endif
# endif
# endif
}
}
bool KviWindow : : focusNextPrevChild ( bool next )
{
TQWidget * w = focusWidget ( ) ;
if ( w )
{
# ifdef COMPILE_USE_QT4
if ( w - > focusPolicy ( ) = = TTQ_StrongFocus ) return false ;
# else
if ( w - > focusPolicy ( ) = = TQ_StrongFocus ) return false ;
# endif
//TQVariant v = w->property("KviProperty_FocusOwner");
//if(v.isValid())return false; // Do NOT change the focus widget!
if ( w - > parent ( ) )
{
# ifdef COMPILE_USE_QT4
if ( w - > parent ( ) - > metaObject ( ) - > indexOfProperty ( " KviProperty_ChildFocusOwner " ) = = - 1 )
# else
if ( w - > parent ( ) - > metaObject ( ) - > findProperty ( " KviProperty_ChildFocusOwner " ) = = - 1 )
# endif
return false ; // Do NOT change the focus widget!
}
}
return TQWidget : : focusNextPrevChild ( next ) ;
}
void KviWindow : : forceTextCodec ( TQTextCodec * c )
{
if ( ! c ) return ;
m_pTextCodec = c ;
TQTextCodec * dc = defaultTextCodec ( ) ;
if ( dc ! = c )
m_szTextEncoding = c - > name ( ) ;
else
m_szTextEncoding = " " ; // this is the default anyway
}
bool KviWindow : : setTextEncoding ( const TQString & szTextEncoding )
{
if ( ! szTextEncoding . isEmpty ( ) )
{
m_pTextCodec = KviLocale : : codecForName ( szTextEncoding . latin1 ( ) ) ;
if ( m_pTextCodec )
{
m_szTextEncoding = szTextEncoding ;
return true ;
}
// this is an error because we specified an encoding
// and we couldn't find a codec for this
} // else it is empty : this means : guess from locale
// either empty or not found...
m_pTextCodec = 0 ;
m_szTextEncoding = " " ; // empty: we're using the default
return false ;
}
TQTextCodec * KviWindow : : defaultTextCodec ( )
{
// if we have a connection try to inherit from there...
if ( connection ( ) )
{
TQTextCodec * c = connection ( ) - > textCodec ( ) ;
if ( c ) return c ;
}
return KviApp : : defaultTextCodec ( ) ;
}
KviTQCString KviWindow : : encodeText ( const TQString & szText )
{
if ( ! m_pTextCodec ) return defaultTextCodec ( ) - > fromUnicode ( szText ) ;
return m_pTextCodec - > fromUnicode ( szText ) ;
}
TQString KviWindow : : decodeText ( const char * szText )
{
if ( ! m_pTextCodec ) return defaultTextCodec ( ) - > toUnicode ( szText ) ;
return m_pTextCodec - > toUnicode ( szText ) ;
}
bool KviWindow : : activityMeter ( unsigned int * , unsigned int * )
{
return false ;
}
const char * KviWindow : : m_typeTable [ KVI_WINDOW_NUM_TYPES + 1 ] =
{
" console " ,
" channel " ,
" query " ,
" help " ,
" terminal " ,
" editor " ,
" dccchat " ,
" dccsend " ,
" socketspy " ,
" links " ,
" tool " ,
" gnutella " ,
" dirbrowser " ,
" dcccanvas " ,
" dccvoice " ,
" list " ,
" offer " ,
" logview " ,
" deadchannel " ,
" deadquery " ,
" scripteditor " ,
" scriptobject " ,
" userwindow " ,
" debug " ,
// <------ NEW TYPES GO HERE!
" unknown "
} ;
const char * KviWindow : : typeString ( )
{
if ( m_iType < KVI_WINDOW_NUM_TYPES )
{
return m_typeTable [ m_iType ] ;
}
return m_typeTable [ KVI_WINDOW_NUM_TYPES ] ;
}
void KviWindow : : setType ( int iType )
{
m_iType = iType ;
}
void KviWindow : : createTaskBarItem ( )
{
if ( m_pTaskBarItem ) return ;
m_pTaskBarItem = g_pFrame - > m_pTaskBar - > addItem ( this ) ;
}
void KviWindow : : destroyTaskBarItem ( )
{
if ( ! m_pTaskBarItem ) return ;
g_pFrame - > m_pTaskBar - > removeItem ( m_pTaskBarItem ) ;
// m_pTaskBarItem = 0; // actually the taskBarItem destructor sets it
}
BUTTON_CLASS * KviWindow : : createToolButton ( TQWidget * par , const char * nam , int pixon , int pixoff , const TQString & tooltip , bool bOn )
{
# ifdef COMPILE_USE_QT4
BUTTON_CLASS * b = new BUTTON_CLASS ( par ) ;
b - > setObjectName ( nam ) ;
b - > setFlat ( true ) ;
b - > setIcon ( TQIcon ( * ( g_pIconManager - > getSmallIcon ( pixon ) ) ) ) ;
# else
BUTTON_CLASS * b = new BUTTON_CLASS ( par , nam ) ;
b - > setToggleButton ( true ) ;
b - > setUsesBigPixmap ( false ) ;
TQIconSet is1 ;
is1 . setPixmap ( * ( g_pIconManager - > getSmallIcon ( pixon ) ) , TQIconSet : : Small , TQIconSet : : Normal , TQIconSet : : On ) ;
is1 . setPixmap ( * ( g_pIconManager - > getSmallIcon ( pixoff ) ) , TQIconSet : : Small , TQIconSet : : Normal , TQIconSet : : Off ) ;
b - > setIconSet ( is1 ) ;
# endif
KviTalToolTip : : add
( b , tooltip ) ;
b - > setOn ( bOn ) ;
return b ;
}
// This is always defined...
void KviWindow : : createCryptControllerButton ( TQWidget * par )
{
# ifdef COMPILE_CRYPT_SUPPORT
m_pCryptControllerButton = new KviWindowToolPageButton ( KVI_SMALLICON_UNLOCKEDOFF , KVI_SMALLICON_UNLOCKED , __tr2qs ( " Crypting " ) , buttonContainer ( ) , false , " crypt_controller_button " ) ;
connect ( m_pCryptControllerButton , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( toggleCryptController ( ) ) ) ;
# endif // COMPILE_CRYPT_SUPPORT
}
void KviWindow : : createTextEncodingButton ( TQWidget * par )
{
if ( m_pTextEncodingButton ) delete m_pTextEncodingButton ;
m_pTextEncodingButton = createToolButton ( par , " text_encoding_button " , KVI_SMALLICON_TEXTENCODING , KVI_SMALLICON_TEXTENCODING , __tr2qs ( " Private Text Encoding " ) , false ) ;
connect ( m_pTextEncodingButton , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( textEncodingButtonClicked ( ) ) ) ;
}
void KviWindow : : textEncodingButtonClicked ( )
{
createSystemTextEncodingPopup ( ) ;
g_pMdiWindowSystemTextEncodingPopup - > popup ( m_pTextEncodingButton - > mapToGlobal ( TQPoint ( 0 , m_pTextEncodingButton - > height ( ) ) ) ) ;
m_pTextEncodingButton - > setOn ( false ) ;
}
const TQString & KviWindow : : lastLineOfText ( )
{
if ( m_pIrcView )
return m_pIrcView - > lastLineOfText ( ) ;
return KviTQString : : empty ;
}
const TQString & KviWindow : : lastMessageText ( )
{
if ( m_pIrcView )
return m_pIrcView - > lastMessageText ( ) ;
return KviTQString : : empty ;
}
// The following three have to be here even if the crypt support is disabled...tqmoc does not support conditional compilations
void KviWindow : : toggleCryptController ( )
{
# ifdef COMPILE_CRYPT_SUPPORT
if ( ! m_pCryptControllerButton - > isOn ( ) )
{
if ( m_pCryptController )
{
delete m_pCryptController ;
m_pCryptController = 0 ;
if ( ! m_pCryptControllerButton )
return ;
if ( m_pCryptControllerButton - > isOn ( ) )
m_pCryptControllerButton - > setOn ( false ) ;
}
} else {
if ( m_pSplitter & & m_pInput )
{
m_pCryptController = new KviCryptController ( m_pSplitter , m_pCryptControllerButton , " crypt_controller " , this , m_pCryptSessionInfo ) ;
connect ( m_pCryptController , TQT_SIGNAL ( done ( ) ) , this , TQT_SLOT ( cryptControllerFinished ( ) ) ) ;
//setFocusHandlerNoClass(m_pInput,m_pCryptController,TQLINEEDIT_OBJECT_NAME_STRING); //link it!
m_pCryptController - > show ( ) ;
if ( ! m_pCryptControllerButton )
return ;
if ( ! ( m_pCryptControllerButton - > isOn ( ) ) )
m_pCryptControllerButton - > setOn ( true ) ;
}
}
# endif // COMPILE_CRYPT_SUPPORT
}
# ifdef COMPILE_CRYPT_SUPPORT
void KviWindow : : setCryptSessionInfo ( KviCryptSessionInfo * inf )
{
if ( m_pCryptSessionInfo )
KviCryptController : : destroyCryptSessionInfo ( & m_pCryptSessionInfo ) ;
m_pCryptSessionInfo = inf ;
if ( m_pCryptSessionInfo )
{
connect ( m_pCryptSessionInfo - > pEngine , TQT_SIGNAL ( destroyed ( ) ) , this , TQT_SLOT ( cryptSessionInfoDestroyed ( ) ) ) ;
}
if ( m_pCryptControllerButton )
{
TQIconSet is ;
is . setPixmap ( * ( g_pIconManager - > getSmallIcon ( m_pCryptSessionInfo ? KVI_SMALLICON_LOCKEDOFF : KVI_SMALLICON_UNLOCKEDOFF ) ) , TQIconSet : : Small , TQIconSet : : Normal , TQIconSet : : Off ) ;
is . setPixmap ( * ( g_pIconManager - > getSmallIcon ( m_pCryptSessionInfo ? KVI_SMALLICON_LOCKED : KVI_SMALLICON_UNLOCKED ) ) , TQIconSet : : Small , TQIconSet : : Normal , TQIconSet : : On ) ;
m_pCryptControllerButton - > setIconSet ( is ) ;
if ( m_pCryptControllerButton - > isOn ( ) )
m_pCryptControllerButton - > setOn ( false ) ;
}
}
# endif // COMPILE_CRYPT_SUPPORT
void KviWindow : : cryptControllerFinished ( )
{
# ifdef COMPILE_CRYPT_SUPPORT
KviCryptSessionInfo * inf = m_pCryptController - > getNewSessionInfo ( ) ;
setCryptSessionInfo ( inf ) ;
delete m_pCryptController ;
m_pCryptController = 0 ;
# endif
}
void KviWindow : : cryptSessionInfoDestroyed ( )
{
# ifdef COMPILE_CRYPT_SUPPORT
output ( KVI_OUT_SYSTEMERROR , __tr2qs ( " Ops...I've accidentally lost the crypting engine... " ) ) ;
m_pCryptSessionInfo - > pEngine = 0 ;
delete m_pCryptSessionInfo ;
m_pCryptSessionInfo = 0 ;
# endif
}
void KviWindow : : setProgress ( int progress )
{
m_pTaskBarItem - > setProgress ( progress ) ;
}
void KviWindow : : listWindowTypes ( )
{
outputNoFmt ( KVI_OUT_SYSTEMMESSAGE , __tr2qs ( " List of window types available in this release of KVIrc: " ) ) ;
for ( int i = 0 ; i < KVI_WINDOW_NUM_TYPES ; i + + )
outputNoFmt ( KVI_OUT_SYSTEMMESSAGE , m_typeTable [ i ] ) ;
}
void KviWindow : : getConfigGroupName ( TQString & buf )
{
buf = typeString ( ) ;
}
void KviWindow : : getDefaultLogFileName ( TQString & buffer )
{
// FIXME: #warning "Make it configurable ?"
TQString date ;
TQDate dt ( TQDate : : currentDate ( ) ) ;
date = dt . toString ( " yyyy.MM.dd " ) ;
TQString base ;
getBaseLogFileName ( base ) ;
kvi_encodeFileName ( base ) ;
base . replace ( " %%2e " , " %2e " ) ;
base = base . lower ( ) ;
TQString tmp ;
if ( KVI_OPTION_BOOL ( KviOption_boolGzipLogs ) )
KviTQString : : sprintf ( tmp , " %s_%s_%s.log.gz " , typeString ( ) , base . utf8 ( ) . data ( ) , date . utf8 ( ) . data ( ) ) ;
else
KviTQString : : sprintf ( tmp , " %s_%s_%s.log " , typeString ( ) , base . utf8 ( ) . data ( ) , date . utf8 ( ) . data ( ) ) ;
g_pApp - > getLocalKvircDirectory ( buffer , KviApp : : Log , tmp ) ;
}
/*void KviWindow::getBaseLogFileName(KviStr &buffer)
{
buffer = m_szName ;
} */
void KviWindow : : getBaseLogFileName ( TQString & buffer )
{
buffer = m_szName ;
}
void KviWindow : : saveProperties ( KviConfig * cfg )
{
// store only the non-default text encoding.
TQString szCodec = m_szTextEncoding ;
TQTextCodec * c = defaultTextCodec ( ) ;
if ( c & & m_pTextCodec )
{
# ifdef COMPILE_USE_QT4
if ( KviTQString : : equalCI ( szCodec , c - > name ( ) . data ( ) ) ) szCodec = KviTQString : : empty ; // store "default"
# else
if ( KviTQString : : equalCI ( szCodec , c - > name ( ) ) ) szCodec = KviTQString : : empty ; // store "default"
# endif
}
TQString szKey = " TextEncoding_ " ;
szKey + = m_szName ;
cfg - > writeEntry ( szKey , szCodec ) ;
if ( m_pInput ) {
cfg - > writeEntry ( " inputToolButtonsHidden " , m_pInput - > isButtonsHidden ( ) ) ;
cfg - > writeEntry ( " commandLineIsUserFriendly " , m_pInput - > isUserFriendly ( ) ) ;
}
//
/*if(m_pIrcView && m_iType==KVI_WINDOW_TYPE_CHANNEL)
if ( m_pIrcView - > isLogging ( ) )
cfg - > writeEntry ( " LoggingEnabled " , m_pIrcView - > isLogging ( ) ) ; */
}
void KviWindow : : loadProperties ( KviConfig * cfg )
{
TQString szKey = " TextEncoding_ " ;
szKey + = m_szName ;
setTextEncoding ( cfg - > readTQStringEntry ( szKey , KviTQString : : empty ) . utf8 ( ) . data ( ) ) ;
if ( m_pInput ) {
m_pInput - > setButtonsHidden ( cfg - > readBoolEntry ( " inputToolButtonsHidden " , KVI_OPTION_BOOL ( KviOption_boolHideInputToolButtons ) ) ) ;
m_pInput - > setUserFriendly ( cfg - > readBoolEntry ( " commandLineIsUserFriendly " , KVI_OPTION_BOOL ( KviOption_boolCommandlineInUserFriendlyModeByDefault ) ) ) ;
}
/* if(m_pIrcView && m_iType==KVI_WINDOW_TYPE_CHANNEL)
{
bool bEnableLogs = cfg - > readBoolEntry ( " LoggingEnabled " , 0 ) ;
if ( ! m_pIrcView - > isLogging ( ) & & bEnableLogs )
{
TQString szTmp ;
getBaseLogFileName ( szTmp ) ;
m_pIrcView - > startLogging ( ) ;
}
} */
}
TQPixmap * KviWindow : : myIconPtr ( )
{
return g_pIconManager - > getSmallIcon ( KVI_SMALLICON_DEFAULTICON ) ;
}
void KviWindow : : getTaskBarTipText ( TQString & buffer )
{
buffer = m_szPlainTextCaption ;
}
void KviWindow : : setFixedCaption ( const TQString & szCaption )
{
m_szPlainTextCaption = szCaption ;
}
void KviWindow : : fillCaptionBuffers ( )
{
TQString szCaption = m_szPlainTextCaption ;
if ( szCaption . isEmpty ( ) )
szCaption = m_szName ;
fillSingleColorCaptionBuffers ( szCaption ) ;
}
void KviWindow : : fillSingleColorCaptionBuffers ( const TQString & szName )
{
static TQString p1 ( " <nobr><font color= \" " ) ;
static TQString p2 ( " \" ><b> " ) ;
static TQString p3 ( " </b></font></nobr> " ) ;
m_szPlainTextCaption = szName ;
m_szHtmlActiveCaption = p1 ;
m_szHtmlActiveCaption + = KVI_OPTION_COLOR ( KviOption_colorCaptionTextActive ) . name ( ) ;
m_szHtmlActiveCaption + = p2 ;
m_szHtmlActiveCaption + = szName ;
m_szHtmlActiveCaption + = p3 ;
m_szHtmlInactiveCaption = p1 ;
m_szHtmlInactiveCaption + = KVI_OPTION_COLOR ( KviOption_colorCaptionTextInactive ) . name ( ) ;
m_szHtmlInactiveCaption + = p2 ;
m_szHtmlInactiveCaption + = szName ;
m_szHtmlInactiveCaption + = p3 ;
}
void KviWindow : : updateCaption ( )
{
fillCaptionBuffers ( ) ;
if ( mdiParent ( ) )
mdiParent ( ) - > setCaption ( plainTextCaption ( ) , htmlActiveCaption ( ) , htmlInactiveCaption ( ) ) ;
else
setCaption ( plainTextCaption ( ) ) ;
if ( m_pTaskBarItem ) m_pTaskBarItem - > captionChanged ( ) ;
if ( mdiParent ( ) & & isMaximized ( ) & & ( g_pActiveWindow = = this ) )
g_pFrame - > updateCaption ( ) ;
}
void KviWindow : : createSystemTextEncodingPopup ( )
{
if ( ! g_pMdiWindowSystemTextEncodingPopup )
g_pMdiWindowSystemTextEncodingPopup = new KviTalPopupMenu ( ) ;
else
{
g_pMdiWindowSystemTextEncodingPopup - > clear ( ) ;
}
if ( ! g_pMdiWindowSystemTextEncodingPopupStandard )
g_pMdiWindowSystemTextEncodingPopupStandard = new KviTalPopupMenu ( ) ;
else
{
g_pMdiWindowSystemTextEncodingPopupStandard - > clear ( ) ;
disconnect ( g_pMdiWindowSystemTextEncodingPopupStandard , TQT_SIGNAL ( activated ( int ) ) , 0 , 0 ) ;
}
if ( ! g_pMdiWindowSystemTextEncodingPopupSmart )
g_pMdiWindowSystemTextEncodingPopupSmart = new KviTalPopupMenu ( ) ;
else
{
g_pMdiWindowSystemTextEncodingPopupSmart - > clear ( ) ;
disconnect ( g_pMdiWindowSystemTextEncodingPopupSmart , TQT_SIGNAL ( activated ( int ) ) , 0 , 0 ) ;
}
if ( ! g_pMdiWindowSystemTextEncodingPopupSmartUtf8 )
g_pMdiWindowSystemTextEncodingPopupSmartUtf8 = new KviTalPopupMenu ( ) ;
else
{
g_pMdiWindowSystemTextEncodingPopupSmartUtf8 - > clear ( ) ;
disconnect ( g_pMdiWindowSystemTextEncodingPopupSmartUtf8 , TQT_SIGNAL ( activated ( int ) ) , 0 , 0 ) ;
}
TQTextCodec * c = defaultTextCodec ( ) ;
TQString tmp = __tr2qs ( " Use Default Encoding " ) ;
if ( c )
{
tmp + = " ( " ;
tmp + = c - > name ( ) ;
tmp + = " ) " ;
}
int id = g_pMdiWindowSystemTextEncodingPopup - > insertItem ( tmp , this , TQT_SLOT ( systemTextEncodingPopupDefault ( ) ) ) ;
if ( m_szTextEncoding . isEmpty ( ) ) g_pMdiWindowSystemTextEncodingPopup - > setItemChecked ( id , true ) ;
g_pMdiWindowSystemTextEncodingPopup - > insertSeparator ( ) ;
g_pMdiWindowSystemTextEncodingPopup - > insertItem ( __tr2qs ( " Standard " ) , g_pMdiWindowSystemTextEncodingPopupStandard ) ;
g_pMdiWindowSystemTextEncodingPopup - > insertItem ( __tr2qs ( " Smart (Send Local) " ) , g_pMdiWindowSystemTextEncodingPopupSmart ) ;
g_pMdiWindowSystemTextEncodingPopup - > insertItem ( __tr2qs ( " Smart (Send UTF-8) " ) , g_pMdiWindowSystemTextEncodingPopupSmartUtf8 ) ;
int i = 0 ;
KviLocale : : EncodingDescription * d = KviLocale : : encodingDescription ( i ) ;
while ( d - > szName )
{
KviTQString : : sprintf ( tmp , " %s (%s) " , d - > szName , d - > szDescription ) ;
KviTalPopupMenu * ppp = d - > bSmart ? ( d - > bSendUtf8 ? g_pMdiWindowSystemTextEncodingPopupSmartUtf8 : g_pMdiWindowSystemTextEncodingPopupSmart ) : g_pMdiWindowSystemTextEncodingPopupStandard ;
id = ppp - > insertItem ( tmp ) ;
if ( KviTQString : : equalCI ( m_szTextEncoding , d - > szName ) )
ppp - > setItemChecked ( id , true ) ;
i = i + 1 ;
d = KviLocale : : encodingDescription ( i ) ;
}
connect ( g_pMdiWindowSystemTextEncodingPopupSmart , TQT_SIGNAL ( activated ( int ) ) , this , TQT_SLOT ( systemTextEncodingPopupSmartActivated ( int ) ) ) ;
connect ( g_pMdiWindowSystemTextEncodingPopupSmartUtf8 , TQT_SIGNAL ( activated ( int ) ) , this , TQT_SLOT ( systemTextEncodingPopupSmartUtf8Activated ( int ) ) ) ;
connect ( g_pMdiWindowSystemTextEncodingPopupStandard , TQT_SIGNAL ( activated ( int ) ) , this , TQT_SLOT ( systemTextEncodingPopupStandardActivated ( int ) ) ) ;
}
void KviWindow : : systemPopupRequest ( const TQPoint & pnt )
{
if ( ! g_pMdiWindowSystemMainPopup )
g_pMdiWindowSystemMainPopup = new KviTalPopupMenu ( ) ;
else
{
g_pMdiWindowSystemMainPopup - > clear ( ) ;
g_pMdiWindowSystemMainPopup - > disconnect ( ) ;
}
if ( mdiParent ( ) )
g_pMdiWindowSystemMainPopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_UNDOCK ) ) ,
__tr2qs ( " &Undock " ) , this , TQT_SLOT ( undock ( ) ) ) ;
else
g_pMdiWindowSystemMainPopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_DOCK ) ) ,
__tr2qs ( " &Dock " ) , this , TQT_SLOT ( dock ( ) ) ) ;
g_pMdiWindowSystemMainPopup - > insertSeparator ( ) ;
int id = g_pMdiWindowSystemMainPopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_MINIMIZE ) ) ,
__tr2qs ( " Mi&nimize " ) , this , TQT_SLOT ( minimize ( ) ) ) ;
g_pMdiWindowSystemMainPopup - > setItemEnabled ( id , ! isMinimized ( ) ) ;
id = g_pMdiWindowSystemMainPopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_MAXIMIZE ) ) ,
__tr2qs ( " Ma&ximize " ) , this , TQT_SLOT ( maximize ( ) ) ) ;
g_pMdiWindowSystemMainPopup - > setItemEnabled ( id , ! isMaximized ( ) ) ;
id = g_pMdiWindowSystemMainPopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_RESTORE ) ) ,
__tr2qs ( " &Restore " ) , this , TQT_SLOT ( restore ( ) ) ) ;
g_pMdiWindowSystemMainPopup - > setItemEnabled ( id , isMinimized ( ) | | isMaximized ( ) ) ;
g_pMdiWindowSystemMainPopup - > insertSeparator ( ) ;
g_pMdiWindowSystemMainPopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_CLOSE ) ) ,
__tr2qs ( " Close " ) , this , TQT_SLOT ( close ( ) ) ) ;
g_pMdiWindowSystemMainPopup - > insertSeparator ( ) ;
if ( m_pTextEncodingButton )
{
createSystemTextEncodingPopup ( ) ;
g_pMdiWindowSystemMainPopup - > insertItem ( __tr2qs ( " Text &Encoding " ) , g_pMdiWindowSystemTextEncodingPopup ) ;
} // else we don't support setting private encoding anyway
g_pMdiWindowSystemMainPopup - > insertItem ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_XY ) ) ,
__tr2qs ( " Sa&ve Window Properties " ) , this , TQT_SLOT ( savePropertiesAsDefault ( ) ) ) ;
fillContextPopup ( g_pMdiWindowSystemMainPopup ) ;
g_pMdiWindowSystemMainPopup - > popup ( pnt ) ;
}
void KviWindow : : systemTextEncodingPopupDefault ( )
{
// default
setTextEncoding ( " " ) ;
}
void KviWindow : : systemTextEncodingPopupSmartActivated ( int id )
{
if ( ! g_pMdiWindowSystemTextEncodingPopupSmart )
return ;
TQString tmp = g_pMdiWindowSystemTextEncodingPopupSmart - > text ( id ) ;
KviTQString : : cutFromFirst ( tmp , " ( " ) ;
setTextEncoding ( tmp ) ;
}
void KviWindow : : systemTextEncodingPopupSmartUtf8Activated ( int id )
{
if ( ! g_pMdiWindowSystemTextEncodingPopupSmartUtf8 )
return ;
TQString tmp = g_pMdiWindowSystemTextEncodingPopupSmartUtf8 - > text ( id ) ;
KviTQString : : cutFromFirst ( tmp , " ( " ) ;
setTextEncoding ( tmp ) ;
}
void KviWindow : : systemTextEncodingPopupStandardActivated ( int id )
{
if ( ! g_pMdiWindowSystemTextEncodingPopupStandard )
return ;
TQString tmp = g_pMdiWindowSystemTextEncodingPopupStandard - > text ( id ) ;
KviTQString : : cutFromFirst ( tmp , " ( " ) ;
setTextEncoding ( tmp ) ;
}
void KviWindow : : savePropertiesAsDefault ( )
{
TQString group ;
getConfigGroupName ( group ) ;
if ( ! kvi_strEqualCI ( group , typeString ( ) ) )
{
// save also the settings for THIS specialized window
g_pFrame - > saveWindowProperties ( this , group ) ;
}
g_pFrame - > saveWindowProperties ( this , typeString ( ) ) ;
}
void KviWindow : : contextPopup ( )
{
systemPopupRequest ( TQCursor : : pos ( ) ) ;
}
void KviWindow : : fillContextPopup ( KviTalPopupMenu * )
{
// nothing here
}
void KviWindow : : undock ( )
{
g_pFrame - > undockWindow ( this ) ;
}
void KviWindow : : dock ( )
{
g_pFrame - > dockWindow ( this ) ;
}
void KviWindow : : delayedAutoRaise ( )
{
TQTimer : : singleShot ( 0 , this , TQT_SLOT ( autoRaise ( ) ) ) ;
}
void KviWindow : : autoRaise ( )
{
if ( ! mdiParent ( ) )
{
raise ( ) ;
setActiveWindow ( ) ;
}
if ( m_pFocusHandler )
m_pFocusHandler - > setFocus ( ) ;
else
setFocus ( ) ;
}
void KviWindow : : delayedClose ( )
{
TQTimer : : singleShot ( 0 , this , TQT_SLOT ( close ( ) ) ) ;
}
void KviWindow : : closeEvent ( TQCloseEvent * e )
{
e - > ignore ( ) ;
g_pFrame - > childWindowCloseRequest ( this ) ;
}
void KviWindow : : updateIcon ( )
{
if ( parent ( ) )
{
( ( KviMdiChild * ) parent ( ) ) - > setIcon ( * myIconPtr ( ) ) ;
} else {
setIcon ( * myIconPtr ( ) ) ;
}
}
void KviWindow : : youAreDocked ( )
{
if ( m_pAccel )
{
delete m_pAccel ;
m_pAccel = 0 ;
}
( ( KviMdiChild * ) parent ( ) ) - > setIcon ( * myIconPtr ( ) ) ;
updateCaption ( ) ;
connect ( ( ( KviMdiChild * ) parent ( ) ) , TQT_SIGNAL ( systemPopupRequest ( const TQPoint & ) ) , this , TQT_SLOT ( systemPopupRequest ( const TQPoint & ) ) ) ;
}
void KviWindow : : youAreUndocked ( )
{
m_pAccel = g_pFrame - > installAccelerators ( this ) ;
setIcon ( * myIconPtr ( ) ) ;
updateCaption ( ) ;
}
# ifdef FocusIn
// Hack for X.h
# undef FocusIn
# endif
void KviWindow : : activateSelf ( )
{
if ( mdiParent ( ) )
mdiParent ( ) - > activate ( false ) ;
g_pFrame - > childWindowActivated ( this ) ;
// this is now done by KviFrame in childWindowActivated
//g_pFrame->m_pTaskBar->setActiveItem(m_pTaskBarItem);
}
void KviWindow : : setFocus ( )
{
// don't trigger the whole TQt focus mechanism..
// just trigger directly our focusInEvent
// so we'll redirect the focus to the m_pFocusHandler
focusInEvent ( 0 ) ;
}
void KviWindow : : focusInEvent ( TQFocusEvent * )
{
if ( m_pLastFocusedChild )
{
if ( m_pLastFocusedChild - > hasFocus ( ) & & m_pLastFocusedChild - > isVisible ( ) )
{
// the last focused child still has focus (ehm ???)
if ( g_pActiveWindow ! = this ) activateSelf ( ) ;
return ;
}
}
if ( ! m_pFocusHandler )
{
// must find one NOW
// we probably have no KviInput since it would have been grabbed anyway
if ( m_pIrcView ) m_pFocusHandler = m_pIrcView ;
else {
# ifdef COMPILE_USE_QT4
TQList < TQObject * > list = tqchildren ( ) ;
for ( TQList < TQObject * > : : Iterator it = list . begin ( ) ; it ! = list . end ( ) ; + + it )
{
TQObject * c = * it ;
if ( c - > isWidgetType ( ) )
{
m_pFocusHandler = ( TQWidget * ) c ;
break ;
}
}
# else
TQObjectList list = childrenListObject ( ) ;
if ( ! list . isEmpty ( ) )
{
for ( TQObject * c = list . first ( ) ; c ; c = list . next ( ) )
{
if ( c - > isWidgetType ( ) )
{
m_pFocusHandler = ( TQWidget * ) c ;
break ;
}
}
}
# endif
}
if ( m_pFocusHandler ) m_pFocusHandler - > setFocus ( ) ;
else {
// else too bad :/
debug ( " No widget able to handle focus for window %s " , name ( ) ) ;
return ;
}
} else {
m_pFocusHandler - > setFocus ( ) ;
}
// Setting the focus to the focus handler usually
// triggers our filter for the tqchildren's focusInEvent.
// This should call activateSelf() and thus
// we should be already the active window at this point.
// If we're not, then run activateSelf() to fix this.
if ( g_pActiveWindow ! = this ) activateSelf ( ) ;
//else debug("ACTIVE WINDOW IS ALREADY THIS");
updateCaption ( ) ;
}
bool KviWindow : : eventFilter ( TQObject * o , TQEvent * e )
{
switch ( e - > type ( ) )
{
case TQEvent : : FocusIn :
m_pLastFocusedChild = ( TQWidget * ) o ;
if ( g_pActiveWindow ! = this ) activateSelf ( ) ;
break ;
case TQEvent : : Enter :
// this is a handler moved here from KviMdiChild::eventFilter
if ( TQApplication : : overrideCursor ( ) )
TQApplication : : restoreOverrideCursor ( ) ;
break ;
case TQEvent : : MouseButtonPress :
# ifdef COMPILE_USE_QT4
if ( ( ( ( TQWidget * ) o ) - > focusPolicy ( ) = = TTQ_NoFocus ) | |
( ( ( TQWidget * ) o ) - > focusPolicy ( ) = = TTQ_TabFocus ) )
# else
if ( ( ( ( TQWidget * ) o ) - > focusPolicy ( ) = = TQ_NoFocus ) | |
( ( ( TQWidget * ) o ) - > focusPolicy ( ) = = TQ_TabFocus ) )
# endif
{
// this will not focus our window
// set the focus to the focus handler
if ( m_pLastFocusedChild )
{
if ( m_pLastFocusedChild - > hasFocus ( ) & & m_pLastFocusedChild - > isVisible ( ) )
return false ;
}
if ( m_pFocusHandler )
{
m_pFocusHandler - > setFocus ( ) ;
} else {
setFocus ( ) ; // we grab the focus (someone must do it , damn :D)
}
}
break ;
case TQEvent : : ChildInserted :
if ( ( ( TQChildEvent * ) e ) - > child ( ) - > isWidgetType ( ) )
childInserted ( ( TQWidget * ) ( ( TQChildEvent * ) e ) - > child ( ) ) ;
break ;
case TQEvent : : ChildRemoved :
if ( ( ( TQChildEvent * ) e ) - > child ( ) - > isWidgetType ( ) )
childRemoved ( ( TQWidget * ) ( ( TQChildEvent * ) e ) - > child ( ) ) ;
break ;
default : /* make gcc happy */ break ;
}
return false ;
}
void KviWindow : : childInserted ( TQWidget * o )
{
o - > removeEventFilter ( this ) ; // ensure that we don't filter twice
o - > installEventFilter ( this ) ; // we filter its events
connect ( o , TQT_SIGNAL ( destroyed ( ) ) , this , TQT_SLOT ( childDestroyed ( ) ) ) ;
if ( o - > inherits ( " KviInput " ) )
m_pFocusHandler = o ;
else
{
# ifdef COMPILE_USE_QT4
if ( ! m_pFocusHandler & & ( o - > focusPolicy ( ) = = TTQ_StrongFocus ) )
# else
if ( ! m_pFocusHandler & & ( o - > focusPolicy ( ) = = TQ_StrongFocus ) )
# endif
{
m_pFocusHandler = o ;
}
}
# ifdef COMPILE_USE_QT4
TQList < TQObject * > list = o - > tqchildren ( ) ;
for ( TQList < TQObject * > : : Iterator it = list . begin ( ) ; it ! = list . end ( ) ; + + it )
{
TQObject * c = * it ;
if ( c - > isWidgetType ( ) )
{
childInserted ( ( TQWidget * ) c ) ;
}
}
# else
TQObjectList list = o - > childrenListObject ( ) ;
if ( ! list . isEmpty ( ) )
{
for ( TQObject * c = list . first ( ) ; c ; c = list . next ( ) )
{
if ( c - > isWidgetType ( ) )
childInserted ( ( TQWidget * ) c ) ;
}
}
# endif
}
void KviWindow : : childDestroyed ( )
{
TQWidget * s = ( TQWidget * ) sender ( ) ;
childRemoved ( s ) ;
}
void KviWindow : : childRemoved ( TQWidget * o )
{
//debug("CHILD REMOVED %d",o);
o - > removeEventFilter ( this ) ;
if ( o = = m_pFocusHandler )
m_pFocusHandler = 0 ;
if ( o = = m_pLastFocusedChild )
m_pLastFocusedChild = 0 ;
# ifdef COMPILE_USE_QT4
TQList < TQObject * > list = o - > tqchildren ( ) ;
for ( TQList < TQObject * > : : Iterator it = list . begin ( ) ; it ! = list . end ( ) ; + + it )
{
TQObject * c = * it ;
if ( c - > isWidgetType ( ) )
{
childRemoved ( ( TQWidget * ) c ) ;
}
}
# else
TQObjectList list = o - > childrenListObject ( ) ;
if ( ! list . isEmpty ( ) )
{
for ( TQObject * c = list . first ( ) ; c ; c = list . next ( ) )
{
if ( c - > isWidgetType ( ) )
childRemoved ( ( TQWidget * ) c ) ;
}
} //else debug("The removed object has no tqchildren");
# endif
}
void KviWindow : : childEvent ( TQChildEvent * e )
{
if ( e - > child ( ) - > isWidgetType ( ) )
{
if ( e - > removed ( ) )
childRemoved ( ( TQWidget * ) ( e - > child ( ) ) ) ;
else
childInserted ( ( TQWidget * ) ( e - > child ( ) ) ) ;
}
TQWidget : : childEvent ( e ) ;
}
void KviWindow : : wheelEvent ( TQWheelEvent * e )
{
/* NOTHING HERE FOR NOW (FIXME) */
}
void KviWindow : : tqchildrenTreeChanged ( TQWidget * widgetAdded )
{
// if(widgetAdded && m_pFocusHandler)setFocusHandler(m_pFocusHandler,widgetAdded);
// FIXME: This might be useless
TQResizeEvent * e = new TQResizeEvent ( size ( ) , size ( ) ) ;
resizeEvent ( e ) ;
delete e ;
}
void KviWindow : : updateBackgrounds ( TQObject * obj )
{
if ( ! obj )
obj = TQT_TQOBJECT ( this ) ;
# ifdef COMPILE_USE_QT4
TQList < TQObject * > list = obj - > tqchildren ( ) ;
if ( list . count ( ) )
{
for ( TQList < TQObject * > : : Iterator it = list . begin ( ) ; it ! = list . end ( ) ; + + it )
{
TQObject * child = * it ;
if ( child - > metaObject ( ) - > indexOfProperty ( " TransparencyCapable " ) ! = - 1 ) {
// if (child->isWidgetType())
( ( TQWidget * ) child ) - > update ( ) ;
}
updateBackgrounds ( child ) ;
}
}
# else
TQObjectList list = obj - > childrenListObject ( ) ;
if ( ! list . isEmpty ( ) )
{
for ( unsigned int i = 0 ; i < list . count ( ) ; i + + )
{
TQObject * child = list . at ( i ) ;
// FIXME: check if this code can work with qt < 3.0.0 too
if ( child - > metaObject ( ) - > findProperty ( " TransparencyCapable " , true ) ! = - 1 )
( ( TQWidget * ) child ) - > update ( ) ;
updateBackgrounds ( child ) ;
}
}
# endif
}
void KviWindow : : moveEvent ( TQMoveEvent * e )
{
# ifdef COMPILE_PSEUDO_TRANSPARENCY
updateBackgrounds ( ) ;
# endif
TQWidget : : moveEvent ( e ) ;
}
void KviWindow : : minimize ( )
{
if ( mdiParent ( ) )
{
if ( ! isMinimized ( ) )
mdiParent ( ) - > minimize ( ) ;
}
else
showMinimized ( ) ;
}
void KviWindow : : maximize ( )
{
if ( mdiParent ( ) )
{
if ( ! isMaximized ( ) )
mdiParent ( ) - > maximize ( ) ;
}
else
showMaximized ( ) ;
autoRaise ( ) ;
}
bool KviWindow : : isMinimized ( )
{
if ( mdiParent ( ) )
return ( mdiParent ( ) - > state ( ) = = KviMdiChild : : Minimized ) ;
else
return TQWidget : : isMinimized ( ) ;
}
bool KviWindow : : isMaximized ( )
{
if ( mdiParent ( ) )
return ( mdiParent ( ) - > state ( ) = = KviMdiChild : : Maximized ) ;
// Heh...how to check it ?
// Empirical check
int wdth = ( g_pApp - > desktop ( ) - > width ( ) * 75 ) / 100 ;
int hght = ( g_pApp - > desktop ( ) - > height ( ) * 75 ) / 100 ;
return ( ( x ( ) < = 1 ) & & ( y ( ) < = 1 ) & & ( width ( ) > = wdth ) & & ( height ( ) > = hght ) ) ;
}
void KviWindow : : restore ( )
{
if ( mdiParent ( ) )
{
if ( isMinimized ( ) | | isMaximized ( ) )
mdiParent ( ) - > restore ( ) ;
}
else
showNormal ( ) ;
autoRaise ( ) ;
}
TQRect KviWindow : : externalGeometry ( )
{
# ifndef Q_OS_MACX
return mdiParent ( ) ? mdiParent ( ) - > restoredGeometry ( ) : frameGeometry ( ) ;
# else
return mdiParent ( ) ? mdiParent ( ) - > restoredGeometry ( ) : tqgeometry ( ) ;
# endif
}
void KviWindow : : applyOptions ( )
{
updateCaption ( ) ;
if ( m_pIrcView ) m_pIrcView - > applyOptions ( ) ;
if ( m_pInput ) m_pInput - > applyOptions ( ) ;
// trick: retqlayout
resize ( width ( ) - 1 , height ( ) - 1 ) ;
resize ( width ( ) + 1 , height ( ) + 1 ) ;
}
KviWindow * KviWindow : : outputProxy ( )
{
return 0 ;
}
void KviWindow : : lostUserFocus ( )
{
if ( ! m_pIrcView ) return ;
if ( m_pIrcView - > hasLineMark ( ) ) m_pIrcView - > clearLineMark ( true ) ;
}
void KviWindow : : internalOutput ( KviIrcView * pView , int msg_type , const kvi_wchar_t * pText , int iFlags )
{
// all roads lead to Rome :)
if ( pView )
{
if ( ( this ! = g_pActiveWindow ) | | ( ! isActiveWindow ( ) ) )
{
if ( ! pView - > hasLineMark ( ) )
{
iFlags | = KviIrcView : : SetLineMark ;
}
}
pView - > appendText ( msg_type , pText , iFlags ) ;
} else {
// Redirect to the output proxy
KviWindow * wnd = outputProxy ( ) ;
if ( wnd ) wnd - > outputNoFmt ( msg_type , pText , iFlags ) ;
}
if ( ! m_pTaskBarItem ) {
return ;
}
// if this option is checked we dont highlight other than channel msg
if ( KVI_OPTION_BOOL ( KviOption_boolHighlightOnlyNormalMsg ) )
{
if ( ( msg_type ! = KVI_OUT_CHANPRIVMSG ) & & ( msg_type ! = KVI_OUT_CHANPRIVMSGCRYPTED ) )
{
if ( ! (
(
KVI_OPTION_BOOL ( KviOption_boolHighlightOnlyNormalMsgQueryToo ) & &
(
( msg_type = = KVI_OUT_TQUERYPRIVMSG ) | | ( msg_type = = KVI_OUT_TQUERYTRACE ) | |
( msg_type = = KVI_OUT_TQUERYPRIVMSGCRYPTED ) | | ( msg_type = = KVI_OUT_TQUERYNOTICE ) | | ( msg_type = = KVI_OUT_TQUERYNOTICECRYPTED )
)
)
| |
(
KVI_OPTION_BOOL ( KviOption_boolHighlightOnlyNormalMsgHighlightInChanToo ) & & ( msg_type = = KVI_OUT_HIGHLIGHT )
)
)
)
return ;
}
}
if ( KVI_OPTION_BOOL ( KviOption_boolHighlightOnlyAtCostumHighlightLevel ) & &
( KVI_OPTION_MSGTYPE ( msg_type ) . level ( ) < ( ( int ) ( KVI_OPTION_UINT ( KviOption_uintMinHighlightLevel ) ) ) ) )
{
return ;
}
m_pTaskBarItem - > highlight ( KVI_OPTION_MSGTYPE ( msg_type ) . level ( ) ) ;
}
void KviWindow : : output ( int msg_type , const char * format , . . . )
{
TQString szFmt ( format ) ;
kvi_va_list l ;
kvi_va_start ( l , format ) ;
TQString szBuf ;
KviTQString : : vsprintf ( szBuf , szFmt , l ) ;
kvi_va_end ( l ) ;
preprocessMessage ( szBuf ) ;
const TQChar * pC = KviTQString : : nullTerminatedArray ( szBuf ) ;
if ( ! pC ) return ;
internalOutput ( m_pIrcView , msg_type , ( kvi_wchar_t * ) pC ) ;
}
void KviWindow : : output ( int msg_type , const TQString & szFmt , . . . )
{
kvi_va_list l ;
kvi_va_start_by_reference ( l , szFmt ) ;
TQString szBuf ;
KviTQString : : vsprintf ( szBuf , szFmt , l ) ;
kvi_va_end ( l ) ;
preprocessMessage ( szBuf ) ;
const TQChar * pC = KviTQString : : nullTerminatedArray ( szBuf ) ;
if ( ! pC ) return ;
internalOutput ( m_pIrcView , msg_type , ( kvi_wchar_t * ) pC ) ;
}
void KviWindow : : output ( int msg_type , const kvi_wchar_t * format , . . . )
{
TQString szFmt = TQString : : fromUtf8 ( KviStr ( format ) . ptr ( ) ) ;
kvi_va_list l ;
kvi_va_start ( l , format ) ;
TQString szBuf ;
KviTQString : : vsprintf ( szBuf , szFmt , l ) ;
kvi_va_end ( l ) ;
preprocessMessage ( szBuf ) ;
const TQChar * pC = KviTQString : : nullTerminatedArray ( szBuf ) ;
if ( ! pC ) return ;
internalOutput ( m_pIrcView , msg_type , ( kvi_wchar_t * ) pC ) ;
}
void KviWindow : : outputNoFmt ( int msg_type , const char * text , int iFlags )
{
TQString szText ( text ) ;
preprocessMessage ( szText ) ;
const TQChar * pC = KviTQString : : nullTerminatedArray ( szText ) ;
if ( ! pC ) return ;
internalOutput ( m_pIrcView , msg_type , ( kvi_wchar_t * ) pC , iFlags ) ;
}
void KviWindow : : outputNoFmt ( int msg_type , const TQString & szText , int iFlags )
{
TQString szBuf ( szText ) ;
preprocessMessage ( szBuf ) ;
const TQChar * pC = KviTQString : : nullTerminatedArray ( szBuf ) ;
if ( ! pC ) return ;
internalOutput ( m_pIrcView , msg_type , ( kvi_wchar_t * ) pC , iFlags ) ;
}
void KviWindow : : unhighlight ( )
{
if ( ! m_pTaskBarItem ) return ;
m_pTaskBarItem - > unhighlight ( ) ;
}
/* This messes up a bit: for example it breaks the WHOIS output where
escapes are already present ( checking for them here would be an overkill ) .
This should be eventually done ONLY for remote user message texts
in the server parser .
Fixed
*/
void KviWindow : : preprocessMessage ( TQString & szMessage )
{
// slow
# ifdef COMPILE_USE_QT4
TQStringList strings = szMessage . split ( " " ) ;
# else
TQStringList strings = TQStringList : : split ( " " , szMessage , TRUE ) ;
# endif
for ( TQStringList : : Iterator it = strings . begin ( ) ; it ! = strings . end ( ) ; + + it ) {
TQString tmp ( * it ) ;
if ( tmp . contains ( ' \r ' ) ) continue ;
tmp = KviMircCntrl : : stripControlBytes ( tmp ) ;
tmp . stripWhiteSpace ( ) ;
if ( m_pConsole )
if ( m_pConsole - > connection ( ) )
if ( m_pConsole - > connection ( ) - > serverInfo ( ) - > supportedChannelTypes ( ) . contains ( tmp [ 0 ] ) )
if ( ( * it ) = = tmp )
* it = TQString ( " \r !c \r %1 \r " ) . tqarg ( * it ) ;
else
{
* it = TQString ( " \r !c%1 \r %2 \r " ) . tqarg ( tmp ) . tqarg ( * it ) ;
}
}
szMessage = strings . join ( " " ) ;
}
# include "kvi_window.moc"