Attachment #59211 for bug #93052

View | Details | Raw Unified | Return to bug 93052
Collapse All | Expand All




#include <qtooltip.h>
#include <qrect.h>
#include <qcursor.h>
#include <qtextcodec.h> 

#include <dom/dom_doc.h>
#include <dom/dom_text.h>
#include <dom/dom_string.h>
#include <dom/dom_element.h>
#include <dom/html_base.h>
#include <dom/html_document.h>

{
	d->xsltParser = new Kopete::XSLT( KopetePrefs::prefs()->styleContents() );
	d->transformAllMessages = ( d->xsltParser->flags() & Kopete::XSLT::TransformAllMessages );
        codepage="Unicode";
	backgroundFile = 0;
	root = 0;
	messageId = 0;

	setMetaRefreshEnabled( false );

	begin();
        write( QString::fromLatin1( "<html><head>\n"
			"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=") +
			encoding() + QString::fromLatin1("\">\n<style>") + styleHTML() +
	QString::fromLatin1("</style></head><body></body></html>") );
	end();

	view()->setFocusPolicy( QWidget::NoFocus );

	new ToolTip( this );

	slotRefreshNodes();
}

void ChatMessagePart::appendMessage( Kopete::Message &message,bool encode)
{
	//parse emoticons and URL now.
	message.setBody( message.parsedBody() , Kopete::Message::ParsedHTML );

	message.setRtfOverride( d->rtfOverride );

	messageMap.append(  message.asXML().toString() );

	uint bufferLen = (uint)KopetePrefs::prefs()->chatViewBufferSize();

	// transform all messages every time. needed for Adium style.

		QDomDocument domMessage = message.asXML();
		domMessage.documentElement().setAttribute( QString::fromLatin1( "id" ), QString::number( messageId ) );
		QString resultHTML = addNickLinks( d->xsltParser->transform( domMessage.toString() ) );
		if(encode && (codepage != "Unicode"))
		{
			QCString locallyEncoded = resultHTML.ascii();
			QTextCodec *codec = QTextCodec::codecForName(codepage.ascii());
			if(codec)
			   resultHTML = codec->toUnicode( locallyEncoded );
		}
		QString direction = ( message.plainBody().isRightToLeft() ? QString::fromLatin1("rtl") : QString::fromLatin1("ltr") );
		DOM::HTMLElement newNode = document().createElement( QString::fromLatin1("span") );
		newNode.setAttribute( QString::fromLatin1("dir"), direction );


// vim: set noet ts=4 sts=4 sw=4:

void ChatMessagePart::slotConvert(const QString& string)
{

    
    DOM::DOMString text=htmlDocument().body().innerHTML();
    if(codepage!="Unicode")
    {
	QCString locallyEncoded;
	QTextCodec *codec = QTextCodec::codecForName(codepage.ascii());
	if(!codec)
	{
		kdDebug()<<"codec for this name not exisit\n";
		return;	
	}
	locallyEncoded=codec->fromUnicode(text.string());
	if(string!="Unicode")
	{
		QTextCodec *codec = QTextCodec::codecForName(string.ascii());
		if(!codec)
		{
			kdDebug()<<"codec for this name not exisit\n";
			return;	
		}
		text=codec->toUnicode(locallyEncoded);
	}
	else 
	    text=QString(locallyEncoded);
    }
    else
    {
	if(string!="Unicode")
	{
		QTextCodec *codec = QTextCodec::codecForName(string.ascii());
		if(!codec)
		{
			kdDebug()<<"codec for this name not exisit\n";
			return;	
		}
		text=codec->toUnicode(text.string().ascii());
	}
    }
    htmlDocument().body().setInnerHTML(text);
    setCodepage(string);    
}

void ChatMessagePart::setCodepage(const QString& page)
{
    codepage=page;
}




	 * use 
	 */
	void keepScrolledDown();
    void setCodepage(const QString& page);

public slots:
	/**

	 * Appends a message to the messave view
	 * @param message The message to be appended
	 */
	void appendMessage( Kopete::Message &message,bool encode=true );
        void slotConvert(const QString& string);

signals:
	/**

	KAction *printAction;
	KAction *closeAction;
	KAction *copyURLAction;
	QString codepage;

	void readOverrides();


Lines 693-700 void ChatView::setCaption( const QString Link Here

(-)../work-orig/kopete-3.4.0/kopete/kopete/chatwindow/chatview.cpp (-2 / +5 lines)
693	void ChatView::appendMessage(Kopete::Message &message)	693	void ChatView::appendMessage(Kopete::Message &message)
694	{	694	{
695	remoteTyping( message.from(), false );	695	remoteTyping( message.from(), false );
696		696
697	messagePart()->appendMessage( message );	697	if ( message.direction() != Kopete::Message::Inbound )
		698	messagePart()->appendMessage( message,false);
		699	else
		700	messagePart()->appendMessage(message);
698	if( !d->isActive )	701	if( !d->isActive )
699	{	702	{
700	switch ( message.importance() )	703	switch ( message.importance() )

Lines 31-36 Link Here

(-)../work-orig/kopete-3.4.0/kopete/kopete/chatwindow/kopetechatwindow.cpp (+122 lines)
31	#include <klocale.h>	31	#include <klocale.h>
32	#include <kmenubar.h>	32	#include <kmenubar.h>
33	#include <kconfig.h>	33	#include <kconfig.h>
		34	#include <kcombobox.h>
34	#include <kpopupmenu.h>	35	#include <kpopupmenu.h>
35	#include <kiconloader.h>	36	#include <kiconloader.h>
36	#include <kdebug.h>	37	#include <kdebug.h>
Lines 48-53 Link Here
48	#include <kstdaccel.h>	49	#include <kstdaccel.h>
49		50
50	#include "chatmessagepart.h"	51	#include "chatmessagepart.h"
		52	#include "chatmemberslistwidget.h"
51	#include "chattexteditpart.h"	53	#include "chattexteditpart.h"
52	#include "chatview.h"	54	#include "chatview.h"
53	#include "../kopeteapplication.h"	55	#include "../kopeteapplication.h"
Lines 163-168 KopeteChatWindow *KopeteChatWindow::wind Link Here
163	return myWindow;	165	return myWindow;
164	}	166	}
165		167
		168	/**
		169	*
		170	* @param parent
		171	* @param name
		172	* @return
		173	*/
166	KopeteChatWindow::KopeteChatWindow( QWidget parent, const char name )	174	KopeteChatWindow::KopeteChatWindow( QWidget parent, const char name )
167	: KParts::MainWindow( parent, name )	175	: KParts::MainWindow( parent, name )
168	{	176	{
Lines 215-220 KopeteChatWindow::KopeteChatWindow( QWid Link Here
215		223
216	KGlobal::config()->setGroup( QString::fromLatin1("ChatWindowSettings") );	224	KGlobal::config()->setGroup( QString::fromLatin1("ChatWindowSettings") );
217	m_alwaysShowTabs = KGlobal::config()->readBoolEntry( QString::fromLatin1("AlwaysShowTabs"), false );	225	m_alwaysShowTabs = KGlobal::config()->readBoolEntry( QString::fromLatin1("AlwaysShowTabs"), false );
		226	kdDebug(14010)<<"creating toolbar"<<endl;
		227	m_encoding=new KComboBox(toolBar("convert"));
		228	initEncodings();
		229
		230
218	// kdDebug( 14010 ) << k_funcinfo << "Open Windows: " << windows.count() << endl;	231	// kdDebug( 14010 ) << k_funcinfo << "Open Windows: " << windows.count() << endl;
219	kapp->ref();	232	kapp->ref();
220	}	233	}
Lines 802-807 void KopeteChatWindow::setActiveView( QW Link Here
802	{	815	{
803	disconnect( m_activeView, SIGNAL( canSendChanged(bool) ), this, SLOT( slotUpdateSendEnabled() ) );	816	disconnect( m_activeView, SIGNAL( canSendChanged(bool) ), this, SLOT( slotUpdateSendEnabled() ) );
804	guiFactory()->removeClient(m_activeView->msgManager());	817	guiFactory()->removeClient(m_activeView->msgManager());
		818	disconnect(m_encoding,SIGNAL(activated( const QString&)),
		819	m_activeView->messagePart(),SLOT(slotConvert( const QString&)));
		820	disconnect(m_encoding,SIGNAL(activated( const QString&)),
		821	this,SLOT(slotEncodingSelected( const QString&)));
		822
805	}	823	}
806		824
807	guiFactory()->addClient(view->msgManager());	825	guiFactory()->addClient(view->msgManager());
Lines 812-822 void KopeteChatWindow::setActiveView( QW Link Here
812		830
813	m_activeView = view;	831	m_activeView = view;
814		832
		833
		834
815	if( !chatViewList.contains( view ) )	835	if( !chatViewList.contains( view ) )
816	attachChatView( view );	836	attachChatView( view );
817		837
818	connect( m_activeView, SIGNAL( canSendChanged(bool) ), this, SLOT( slotUpdateSendEnabled() ) );	838	connect( m_activeView, SIGNAL( canSendChanged(bool) ), this, SLOT( slotUpdateSendEnabled() ) );
819		839
		840	Kopete::ContactPtrList cList;
		841	cList=m_activeView->membersList()->session()->members();
		842	Kopete::Contact* ct;
		843	ct=cList.first();
		844	QString uid;
		845	if(ct)
		846	{
		847	KConfig* cf=KGlobal::config();
		848	uid=ct->contactId();
		849	QString gr=cf->group();
		850	cf->setGroup("Encodings");
		851	QString enc=cf->readEntry(uid,"Unicode");
		852	cf->setGroup(gr);
		853	m_activeView->messagePart()->slotConvert(enc);
		854	int i;
		855	for(i=0;i<m_encoding->maxCount();i++)
		856	{
		857	if(m_encoding->text(i)==enc)
		858	{
		859	m_encoding->setCurrentItem(i);
		860	break;
		861	}
		862	}
		863	}
		864
		865	connect(m_encoding,SIGNAL(activated( const QString&)),
		866	m_activeView->messagePart(),SLOT(slotConvert( const QString&)));
		867	connect(m_encoding,SIGNAL(activated( const QString&)),
		868	this,SLOT(slotEncodingSelected( const QString&)));
		869
820	//Tell it it is active	870	//Tell it it is active
821	m_activeView->setActive( true );	871	m_activeView->setActive( true );
822		872
Lines 1120-1125 void KopeteChatWindow::slotConfKeys() Link Here
1120	dlg.configure();	1170	dlg.configure();
1121	}	1171	}
1122		1172
		1173	/**
		1174	*
		1175	*/
1123	void KopeteChatWindow::slotConfToolbar()	1176	void KopeteChatWindow::slotConfToolbar()
1124	{	1177	{
1125	saveMainWindowSettings(KGlobal::config(), QString::fromLatin1( "KopeteChatWindow" ));	1178	saveMainWindowSettings(KGlobal::config(), QString::fromLatin1( "KopeteChatWindow" ));
Lines 1142-1144 void KopeteChatWindow::slotConfToolbar() Link Here
1142		1195
1143	// vim: set noet ts=4 sts=4 sw=4:	1196	// vim: set noet ts=4 sts=4 sw=4:
1144		1197
		1198
		1199
		1200	void KopeteChatWindow::initEncodings()
		1201	{
		1202	QStringList lst=QStringList::split('\n',
		1203	"Unicode\n\
		1204	Big5\n\
		1205	Big5-HKSCS\n\
		1206	eucJP\n\
		1207	eucKR\n\
		1208	GB2312\n\
		1209	GBK\n\
		1210	GB18030\n\
		1211	JIS7\n\
		1212	Shift-JIS\n\
		1213	TSCII\n\
		1214	KOI8-R\n\
		1215	KOI8-U\n\
		1216	ISO8859-1\n\
		1217	ISO8859-2\n\
		1218	ISO8859-3\n\
		1219	ISO8859-4\n\
		1220	ISO8859-5\n\
		1221	ISO8859-6\n\
		1222	ISO8859-7\n\
		1223	ISO8859-8\n\
		1224	ISO8859-8-i\n\
		1225	ISO8859-9\n\
		1226	ISO8859-10\n\
		1227	ISO8859-13\n\
		1228	ISO8859-14\n\
		1229	ISO8859-15\n\
		1230	IBM 850\n\
		1231	IBM 866\n\
		1232	CP874\n\
		1233	CP1250\n\
		1234	CP1251\n\
		1235	CP1252\n\
		1236	CP1253\n\
		1237	CP1254\n\
		1238	CP1255\n\
		1239	CP1256\n\
		1240	CP1257\n\
		1241	CP1258\n\
		1242	Apple Roman\n\
		1243	TIS-620");
		1244	m_encoding->insertStringList(lst);
		1245	}
		1246
		1247
		1248	void KopeteChatWindow::slotEncodingSelected(const QString& string)
		1249	{
		1250	if(!m_activeView)
		1251	return;
		1252	Kopete::ContactPtrList cList;
		1253	cList=m_activeView->membersList()->session()->members();
		1254	Kopete::Contact* ct;
		1255	ct=cList.first();
		1256	QString uid;
		1257	if(ct)
		1258	{
		1259	KConfig* cf=KGlobal::config();
		1260	uid=ct->contactId();
		1261	QString gr=cf->group();
1262	cf->setGroup("Encodings");
1263	cf->writeEntry(uid,string);
1264	cf->setGroup(gr);
1265	}
1266	}




/*
    kopetechatwindow.cpp - Chat Window

    Copyright (c) 2002-2005 by Olivier Goffart       <ogoffart@ kde.org>
    Copyright (c) 2003-2004 by Richard Smith         <kde@metafoo.co.uk>
    Copyright (C) 2002      by James Grant
    Copyright (c) 2002      by Stefan Gehn           <metz AT gehn.net>
    Copyright (c) 2002-2004 by Martijn Klingens      <klingens@kde.org>

    Kopete    (c) 2002-2005 by the Kopete developers <kopete-devel@kde.org>

    *************************************************************************
    *                                                                       *
    * 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 option) any later version.                                   *
    *                                                                       *
    *************************************************************************
*/

#include <qtimer.h>
#include <qhbox.h>
#include <qvbox.h>
#include <qlayout.h>
#include <qtooltip.h>
#include <qfileinfo.h>

#include <kapplication.h>
#include <kcursor.h>
#include <klocale.h>
#include <kmenubar.h>
#include <kconfig.h>
#include <kpopupmenu.h>
#include <kiconloader.h>
#include <kdebug.h>
#include <kwin.h>
#include <ktempfile.h>
#include <kkeydialog.h>
#include <kedittoolbar.h>
#include <kstatusbar.h>
#include <kpushbutton.h>
#include <ktabwidget.h>
#include <kstandarddirs.h>
#include <kdialog.h>
#include <kstringhandler.h>
#include <ksqueezedtextlabel.h>
#include <kstdaccel.h>

#include "chatmessagepart.h"
#include "chattexteditpart.h"
#include "chatview.h"
#include "../kopeteapplication.h"
#include "kopetechatwindow.h"
#include "kopeteemoticonaction.h"
#include "kopetegroup.h"
#include "kopetemessagemanager.h"
#include "kopetemetacontact.h"
#include "kopetepluginmanager.h"
#include "kopeteprefs.h"
#include "kopeteprotocol.h"
#include "kopetestdaction.h"
#include "kopeteviewmanager.h"

#include <qtoolbutton.h>
#include <kactionclasses.h>

typedef QMap<Kopete::Account*,KopeteChatWindow*> AccountMap;
typedef QMap<Kopete::Group*,KopeteChatWindow*> GroupMap;
typedef QMap<Kopete::MetaContact*,KopeteChatWindow*> MetaContactMap;
typedef QPtrList<KopeteChatWindow> WindowList;

namespace
{
	AccountMap accountMap;
	GroupMap groupMap;
	MetaContactMap mcMap;
	WindowList windows;
}

KopeteChatWindow *KopeteChatWindow::window( Kopete::ChatSession *manager )
{
	bool windowCreated = false;
	KopeteChatWindow *myWindow;

	//Take the first and the first? What else?
	Kopete::Group *group = 0L;
	Kopete::ContactPtrList members = manager->members();
	Kopete::MetaContact *metaContact = members.first()->metaContact();

	if ( metaContact )
	{
		Kopete::GroupList gList = metaContact->groups();
		group = gList.first();
	}

	switch( KopetePrefs::prefs()->chatWindowPolicy() )
	{
		case GROUP_BY_ACCOUNT: //Open chats from the same protocol in the same window
			if( accountMap.contains( manager->account() ) )
				myWindow = accountMap[ manager->account() ];
			else
				windowCreated = true;
			break;

		case GROUP_BY_GROUP: //Open chats from the same group in the same window
			if( group && groupMap.contains( group ) )
				myWindow = groupMap[ group ];
			else
				windowCreated = true;
			break;

		case GROUP_BY_METACONTACT: //Open chats from the same metacontact in the same window
			if( mcMap.contains( metaContact ) )
				myWindow = mcMap[ metaContact ];
			else
				windowCreated = true;
			break;

		case GROUP_ALL: //Open all chats in the same window
			if( windows.isEmpty() )
				windowCreated = true;
			else
			{
				//Here we are finding the window with the most tabs and
				//putting it there. Need this for the cases where config changes
				//midstream

				int viewCount = -1;
				for ( KopeteChatWindow *thisWindow = windows.first(); thisWindow; thisWindow = windows.next() )
				{
					if( thisWindow->chatViewCount() > viewCount )
					{
						myWindow = thisWindow;
						viewCount = thisWindow->chatViewCount();
					}
				}
			}
			break;

		case NEW_WINDOW: //Open every chat in a new window
		default:
			windowCreated = true;
			break;
	}

	if ( windowCreated )
	{
		myWindow = new KopeteChatWindow();

		if ( !accountMap.contains( manager->account() ) )
			accountMap.insert( manager->account(), myWindow );

		if ( !mcMap.contains( metaContact ) )
			mcMap.insert( metaContact, myWindow );

		if ( group && !groupMap.contains( group ) )
			groupMap.insert( group, myWindow );
	}

//	kdDebug( 14010 ) << k_funcinfo << "Open Windows: " << windows.count() << endl;

	return myWindow;
}

KopeteChatWindow::KopeteChatWindow( QWidget *parent, const char* name )
	: KParts::MainWindow( parent, name )
{
	m_activeView = 0L;
	m_popupView = 0L;
	backgroundFile = 0L;
	updateBg = true;
	m_tabBar = 0L;

	initActions();

	QVBox *vBox = new QVBox( this );
	vBox->setLineWidth( 0 );
	vBox->setSpacing( 0 );
	vBox->setFrameStyle( QFrame::NoFrame );
	// set default window size.  This could be removed by fixing the size hints of the contents
	resize( 500, 500 );
	setCentralWidget( vBox );

	mainArea = new QFrame( vBox );
	mainArea->setLineWidth( 0 );
	mainArea->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding ) );
	mainLayout = new QVBoxLayout( mainArea );

	if ( KopetePrefs::prefs()->chatWShowSend() )
	{
		//Send Button
		m_button_send = new KPushButton( i18n("Send"), statusBar() );
		m_button_send->setSizePolicy( QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum ) );
		m_button_send->setEnabled( false );
		m_button_send->setFont( statusBar()->font() );
		m_button_send->setFixedHeight( statusBar()->sizeHint().height() );
		connect( m_button_send, SIGNAL( clicked() ), this, SLOT( slotSendMessage() ) );
		statusBar()->addWidget( m_button_send, 0, true );
	}
	else
		m_button_send = 0L;

	m_status_text = new KSqueezedTextLabel( i18n("Ready."), statusBar(), "m_status_text" );
	m_status_text->setAlignment( AlignLeft | AlignVCenter );
	m_status_text->setFont( statusBar()->font() );
	m_status_text->setFixedHeight( statusBar()->sizeHint().height() );
	statusBar()->addWidget( m_status_text, 1 );

	readOptions();
	setWFlags( Qt::WDestructiveClose );

	windows.append( this );
	windowListChanged();

	KGlobal::config()->setGroup( QString::fromLatin1("ChatWindowSettings") );
	m_alwaysShowTabs = KGlobal::config()->readBoolEntry( QString::fromLatin1("AlwaysShowTabs"), false );
//	kdDebug( 14010 ) << k_funcinfo << "Open Windows: " << windows.count() << endl;
	kapp->ref();
}

KopeteChatWindow::~KopeteChatWindow()
{
	//	kdDebug( 14010 ) << k_funcinfo << endl;

	emit( closing( this ) );

	for( AccountMap::Iterator it = accountMap.begin(); it != accountMap.end(); )
	{
		AccountMap::Iterator mayDeleteIt = it;
		++it;
		if( mayDeleteIt.data() == this )
			accountMap.remove( mayDeleteIt.key() );
	}

	for( GroupMap::Iterator it = groupMap.begin(); it != groupMap.end(); )
	{
		GroupMap::Iterator mayDeleteIt = it;
		++it;
		if( mayDeleteIt.data() == this )
			groupMap.remove( mayDeleteIt.key() );
	}

	for( MetaContactMap::Iterator it = mcMap.begin(); it != mcMap.end(); )
	{
		MetaContactMap::Iterator mayDeleteIt = it;
		++it;
		if( mayDeleteIt.data() == this )
			mcMap.remove( mayDeleteIt.key() );
	}

	windows.remove( this );
	windowListChanged();

//	kdDebug( 14010 ) << "Open Windows: " << windows.count() << endl;

	saveOptions();

	if( backgroundFile )
	{
		backgroundFile->close();
		backgroundFile->unlink();
		delete backgroundFile;
	}

	delete anim;
	kapp->deref();
}

void KopeteChatWindow::windowListChanged()
{
	// update all windows' Move Tab to Window action
	for ( QPtrListIterator<KopeteChatWindow> it( windows ); *it; ++it )
		(*it)->checkDetachEnable();
}

void KopeteChatWindow::slotNickComplete()
{
	if( m_activeView )
		m_activeView->nickComplete();
}

void KopeteChatWindow::slotTabContextMenu( QWidget *tab, const QPoint &pos )
{
	m_popupView = static_cast<ChatView*>( tab );

	KPopupMenu *popup = new KPopupMenu;
	popup->insertTitle( KStringHandler::rsqueeze( m_popupView->caption() ) );

	actionContactMenu->plug( popup );
	popup->insertSeparator();
	actionTabPlacementMenu->plug( popup );
	tabDetach->plug( popup );
	actionDetachMenu->plug( popup );
	tabClose->plug( popup );
	popup->exec( pos );

	delete popup;
	m_popupView = 0;
}

ChatView *KopeteChatWindow::activeView()
{
	return m_activeView;
}

void KopeteChatWindow::initActions(void)
{
	KActionCollection *coll = actionCollection();

	createStandardStatusBarAction();

	chatSend = new KAction( i18n( "&Send Message" ), QString::fromLatin1( "mail_send" ), 0,
		this, SLOT( slotSendMessage() ), coll, "chat_send" );
	//Default to 'Return' for sending messages
	chatSend->setShortcut( QKeySequence(Key_Return) );
	chatSend->setEnabled( false );

 	KStdAction::save ( this, SLOT(slotChatSave()), coll );
 	KStdAction::print ( this, SLOT(slotChatPrint()), coll );
	KStdAction::quit ( this, SLOT(close()), coll );

	tabClose = KStdAction::close ( this, SLOT(slotChatClosed()), coll, "tabs_close" );

	tabRight=new KAction( i18n( "&Activate Next Tab" ), 0, KStdAccel::tabNext(),
		this, SLOT( slotNextTab() ), coll, "tabs_right" );
	tabLeft=new KAction( i18n( "&Activate Previous Tab" ), 0, KStdAccel::tabPrev(),
		this, SLOT( slotPreviousTab() ), coll, "tabs_left" );
	tabLeft->setEnabled( false );
	tabRight->setEnabled( false );

	nickComplete = new KAction( i18n( "Nic&k Completion" ), QString::null, 0, this, SLOT( slotNickComplete() ), coll , "nick_compete");
	nickComplete->setShortcut( QKeySequence( Key_Tab ) );

	tabDetach = new KAction( i18n( "&Detach Chat" ), QString::fromLatin1( "tab_breakoff" ), 0,
		this, SLOT( slotDetachChat() ), coll, "tabs_detach" );
	tabDetach->setEnabled( false );

	actionDetachMenu = new KActionMenu( i18n( "&Move Tab to Window" ), QString::fromLatin1( "tab_breakoff" ), coll, "tabs_detachmove" );
	actionDetachMenu->setDelayed( false );

	connect ( actionDetachMenu->popupMenu(), SIGNAL(aboutToShow()), this, SLOT(slotPrepareDetachMenu()) );
	connect ( actionDetachMenu->popupMenu(), SIGNAL(activated(int)), this, SLOT(slotDetachChat(int)) );

	actionTabPlacementMenu = new KActionMenu( i18n( "&Tab Placement" ), coll, "tabs_placement" );
	connect ( actionTabPlacementMenu->popupMenu(), SIGNAL(aboutToShow()), this, SLOT(slotPreparePlacementMenu()) );
	connect ( actionTabPlacementMenu->popupMenu(), SIGNAL(activated(int)), this, SLOT(slotPlaceTabs(int)) );

	tabDetach->setShortcut( QKeySequence(CTRL + SHIFT + Key_B) );

	KStdAction::cut( this, SLOT(slotCut()), coll);
	KStdAction::copy( this, SLOT(slotCopy()), coll);
	KStdAction::paste( this, SLOT(slotPaste()), coll);

	new KAction( i18n( "Set Default &Font..." ), QString::fromLatin1( "charset" ), 0, this, SLOT( slotSetFont() ), coll, "format_font" );
	new KAction( i18n( "Set Default Text &Color..." ), QString::fromLatin1( "pencil" ), 0, this, SLOT( slotSetFgColor() ), coll, "format_fgcolor" );
	new KAction( i18n( "Set &Background Color..." ), QString::fromLatin1( "fill" ), 0, this, SLOT( slotSetBgColor() ), coll, "format_bgcolor" );

	historyUp = new KAction( i18n( "Previous History" ), QString::null, 0,
		this, SLOT( slotHistoryUp() ), coll, "history_up" );
	historyUp->setShortcut( QKeySequence(CTRL + Key_Up) );

	historyDown = new KAction( i18n( "Next History" ), QString::null, 0,
		this, SLOT( slotHistoryDown() ), coll, "history_down" );
	historyDown->setShortcut( QKeySequence(CTRL + Key_Down) );

	KStdAction::prior( this, SLOT( slotPageUp() ), coll, "scroll_up" );
	KStdAction::next( this, SLOT( slotPageDown() ), coll, "scroll_down" );

	KStdAction::showMenubar( this, SLOT(slotViewMenuBar()), coll );

	membersLeft = new KToggleAction( i18n( "Place to Left of Chat Area" ), QString::null, 0,
		this, SLOT( slotViewMembersLeft() ), coll, "options_membersleft" );
	membersRight = new KToggleAction( i18n( "Place to Right of Chat Area" ), QString::null, 0,
		this, SLOT( slotViewMembersRight() ), coll, "options_membersright" );
	toggleMembers = new KToggleAction( i18n( "Show" ), QString::null, 0,
		this, SLOT( slotToggleViewMembers() ), coll, "options_togglemembers" );
#if KDE_IS_VERSION(3,2,90)
	toggleMembers->setCheckedState(i18n("Hide"));
#endif

	actionSmileyMenu = new KopeteEmoticonAction( coll, "format_smiley" );
	actionSmileyMenu->setDelayed( false );
	connect(actionSmileyMenu, SIGNAL(activated(const QString &)), this, SLOT(slotSmileyActivated(const QString &)));

	actionContactMenu = new KActionMenu(i18n("Co&ntacts"), coll, "contacts_menu" );
	actionContactMenu->setDelayed( false );
	connect ( actionContactMenu->popupMenu(), SIGNAL(aboutToShow()), this, SLOT(slotPrepareContactMenu()) );

	// add configure key bindings menu item
#if KDE_IS_VERSION(3, 2, 90)
	KStdAction::keyBindings( guiFactory(), SLOT( configureShortcuts() ), coll );
#else  // when we will drop the KDE 3.2 compatibility, do not forget to remove  slotConfKeys
	KStdAction::keyBindings( this, SLOT( slotConfKeys() ), coll );
	#endif


	KStdAction::configureToolbars(this, SLOT(slotConfToolbar()), coll);
	KopeteStdAction::preferences( coll , "settings_prefs" );

	//The Sending movie
	normalIcon = QPixmap( BarIcon( QString::fromLatin1( "kopete" ) ) );
	animIcon = KGlobal::iconLoader()->loadMovie( QString::fromLatin1( "newmessage" ), KIcon::Toolbar);

	// Pause the animation because otherwise it's running even when we're not
	// showing it. This eats resources, and also triggers a pixmap leak in
	// QMovie in at least Qt 3.1, Qt 3.2 and the current Qt 3.3 beta
	if( !animIcon.isNull() )  //and another QT bug:  it crash if we pause a null movie
		animIcon.pause();

	// we can't set the tool bar as parent, if we do, it will be deleted when we configure toolbars
	anim = new QLabel( QString::null, 0L ,"kde toolbar widget" );
	anim->setMargin(5);
	anim->setPixmap( normalIcon );


	new KWidgetAction( anim , i18n("Toolbar Animation") , 0, 0 , 0 , coll , "toolbar_animation");

	//toolBar()->insertWidget( 99, anim->width(), anim );
	//toolBar()->alignItemRight( 99 );
	setStandardToolBarMenuEnabled( true );

	setXMLFile( QString::fromLatin1( "kopetechatwindow.rc" ) );
	createGUI( 0L );

#if !KDE_IS_VERSION( 3, 1, 90 )
	mStatusbarAction->setChecked(!statusBar()->isHidden());
#endif
}

const QString KopeteChatWindow::fileContents( const QString &path ) const
{
 	QString contents;
	QFile file( path );
	if ( file.open( IO_ReadOnly ) )
	{
		QTextStream stream( &file );
		contents = stream.read();
		file.close();
	}

	return contents;
}

void KopeteChatWindow::slotStopAnimation( ChatView* view )
{
	if( view == m_activeView )
		anim->setPixmap( normalIcon );
}

void KopeteChatWindow::slotUpdateSendEnabled()
{
	if ( !m_activeView ) return;

	bool enabled = m_activeView->canSend();
	chatSend->setEnabled( enabled );
	if(m_button_send)
		m_button_send->setEnabled( enabled );
}

void KopeteChatWindow::updateMembersActions()
{
	if( m_activeView )
	{
		const KDockWidget::DockPosition pos = m_activeView->membersListPosition();
		bool visibleMembers = m_activeView->visibleMembersList();
		membersLeft->setChecked( pos == KDockWidget::DockLeft  );
		membersLeft->setEnabled( visibleMembers );
		membersRight->setChecked( pos == KDockWidget::DockRight );
		membersRight->setEnabled( visibleMembers );
		toggleMembers->setChecked( visibleMembers );
	}
}

void KopeteChatWindow::slotViewMembersLeft()
{
	m_activeView->placeMembersList( KDockWidget::DockLeft );
	updateMembersActions();
}

void KopeteChatWindow::slotViewMembersRight()
{
	m_activeView->placeMembersList( KDockWidget::DockRight );
	updateMembersActions();
}

void KopeteChatWindow::slotToggleViewMembers()
{
	m_activeView->toggleMembersVisibility();
	updateMembersActions();
}

void KopeteChatWindow::slotHistoryUp()
{
	if( m_activeView )
		m_activeView->editPart()->historyUp();
}

void KopeteChatWindow::slotHistoryDown()
{
	if( m_activeView )
		m_activeView->editPart()->historyDown();
}

void KopeteChatWindow::slotPageUp()
{
	if( m_activeView )
		m_activeView->messagePart()->pageUp();
}

void KopeteChatWindow::slotPageDown()
{
	if( m_activeView )
		m_activeView->messagePart()->pageDown();
}

void KopeteChatWindow::slotCut()
{
	m_activeView->cut();
}

void KopeteChatWindow::slotCopy()
{
	m_activeView->copy();
}

void KopeteChatWindow::slotPaste()
{
	m_activeView->paste();
}


void KopeteChatWindow::slotSetFont()
{
	m_activeView->setFont();
}

void KopeteChatWindow::slotSetFgColor()
{
	m_activeView->setFgColor();
}

void KopeteChatWindow::slotSetBgColor()
{
	m_activeView->setBgColor();
}

void KopeteChatWindow::setStatus(const QString &text)
{
	m_status_text->setText(text);
}

void KopeteChatWindow::createTabBar()
{
	if( !m_tabBar )
	{
		KGlobal::config()->setGroup( QString::fromLatin1("ChatWindowSettings") );

		m_tabBar = new KTabWidget( mainArea );
		m_tabBar->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding ) );
		m_tabBar->setHoverCloseButton(KGlobal::config()->readBoolEntry( QString::fromLatin1("HoverClose"), false ));
		m_tabBar->setTabReorderingEnabled(true);
		m_tabBar->setAutomaticResizeTabs(true);
		connect( m_tabBar, SIGNAL( closeRequest( QWidget* )), this, SLOT( slotCloseChat( QWidget* ) ) );

		QToolButton* m_rightWidget = new QToolButton( m_tabBar );
		connect( m_rightWidget, SIGNAL( clicked() ), this, SLOT( slotChatClosed() ) );
		m_rightWidget->setIconSet( SmallIcon( "tab_remove" ) );
		m_rightWidget->adjustSize();
		QToolTip::add( m_rightWidget, i18n("Close the current tab"));
		m_tabBar->setCornerWidget( m_rightWidget, QWidget::TopRight );

		mainLayout->addWidget( m_tabBar );
		m_tabBar->show();
		connect ( m_tabBar, SIGNAL(currentChanged(QWidget *)), this, SLOT(setActiveView(QWidget *)) );
		connect ( m_tabBar, SIGNAL(contextMenu(QWidget *, const QPoint & )), this, SLOT(slotTabContextMenu( QWidget *, const QPoint & )) );

		for( ChatView *view = chatViewList.first(); view; view = chatViewList.next() )
			addTab( view );

		if( m_activeView )
			m_tabBar->showPage( m_activeView );
		else
			setActiveView( chatViewList.first() );

		int tabPosition = KGlobal::config()->readNumEntry( QString::fromLatin1("Tab Placement") , 0 );
		slotPlaceTabs( tabPosition );
	}
}

void KopeteChatWindow::slotCloseChat( QWidget *chatView )
{
	static_cast<ChatView*>( chatView )->closeView();
}

void KopeteChatWindow::addTab( ChatView *view )
{
	QPtrList<Kopete::Contact> chatMembers=view->msgManager()->members();
	Kopete::Contact *c=0L;
	for ( Kopete::Contact *contact = chatMembers.first(); contact; contact = chatMembers.next() )
	{
		if(!c || c->onlineStatus() < contact->onlineStatus())
			c=contact;
	}
	QPixmap pluginIcon = c ? view->msgManager()->contactOnlineStatus( c ).iconFor( c) : SmallIcon( view->msgManager()->protocol()->pluginIcon() );

	view->reparent( m_tabBar, 0, QPoint(), true );
	m_tabBar->addTab( view, pluginIcon, QString::null );
	view->setTabBar( m_tabBar );
	if( view == m_activeView )
		view->show();
	else
		view->hide();
	view->setCaption( view->caption(), false );
}

void KopeteChatWindow::setPrimaryChatView( ChatView *view )
{
	//TODO figure out what else we have to save here besides the font
	//reparent clears a lot of stuff out
	QFont savedFont = view->font();
	view->reparent( mainArea, 0, QPoint(), true );
	view->setTabBar( 0L );
	view->setFont( savedFont );
	view->show();

	mainLayout->addWidget( view );
	setActiveView( view );
}

void KopeteChatWindow::deleteTabBar()
{
	if( m_tabBar )
	{
		disconnect ( m_tabBar, SIGNAL(currentChanged(QWidget *)), this, SLOT(setActiveView(QWidget *)) );
		disconnect ( m_tabBar, SIGNAL(contextMenu(QWidget *, const QPoint & )), this, SLOT(slotTabContextMenu( QWidget *, const QPoint & )) );

		if( !chatViewList.isEmpty() )
			setPrimaryChatView( chatViewList.first() );

		m_tabBar->deleteLater();
		m_tabBar = 0L;
	}
}

void KopeteChatWindow::attachChatView( ChatView* newView )
{
	chatViewList.append( newView );

	if ( !m_alwaysShowTabs && chatViewList.count() == 1 )
		setPrimaryChatView( newView );
	else
	{
		if ( !m_tabBar )
			createTabBar();
		else
			addTab( newView );
		newView->setActive( false );
	}

	newView->setMainWindow( this );
	newView->editWidget()->installEventFilter( this );

	KCursor::setAutoHideCursor( newView->editWidget(), true, true );
	connect( newView, SIGNAL(captionChanged( bool)), this, SLOT(slotSetCaption(bool)) );
	connect( newView, SIGNAL(messageSuccess( ChatView* )), this, SLOT(slotStopAnimation( ChatView* )) );
	connect( newView, SIGNAL(updateStatusIcon( const ChatView* )), this, SLOT(slotUpdateCaptionIcons( const ChatView* )) );

	checkDetachEnable();
}

void KopeteChatWindow::checkDetachEnable()
{
	bool haveTabs = (chatViewList.count() > 1);
	tabDetach->setEnabled( haveTabs );
	tabLeft->setEnabled( haveTabs );
	tabRight->setEnabled( haveTabs );
	actionTabPlacementMenu->setEnabled( m_tabBar != 0 );

	bool otherWindows = (windows.count() > 1);
	actionDetachMenu->setEnabled( otherWindows );
}

void KopeteChatWindow::detachChatView( ChatView *view )
{
	if( !chatViewList.removeRef( view ) )
		return;

	disconnect( view, SIGNAL(captionChanged( bool)), this, SLOT(slotSetCaption(bool)) );
	disconnect( view, SIGNAL(updateStatusIcon( const ChatView *)), this, SLOT(slotUpdateCaptionIcons( const ChatView * )) );
	view->editWidget()->removeEventFilter( this );

	if( m_tabBar )
	{
		int curPage = m_tabBar->currentPageIndex();
		QWidget *page = m_tabBar->page( curPage );

		// if the current view is to be detached, switch to a different one
		if( page == view )
		{
			if( curPage > 0 )
				m_tabBar->setCurrentPage( curPage - 1 );
			else
				m_tabBar->setCurrentPage( curPage + 1 );
		}

		view->setTabBar( 0L );
		m_tabBar->removePage( view );

		if( m_tabBar->currentPage() )
			setActiveView( static_cast<ChatView*>(m_tabBar->currentPage()) );
	}

	if( chatViewList.isEmpty() )
		close();
	else if( !m_alwaysShowTabs && chatViewList.count() == 1)
		deleteTabBar();

	checkDetachEnable();
}

void KopeteChatWindow::slotDetachChat( int newWindowIndex )
{
	KopeteChatWindow *newWindow = 0L;
	ChatView *detachedView;

	if( m_popupView )
		detachedView = m_popupView;
	else
		detachedView = m_activeView;

	if( !detachedView )
		return;

	//if we don't do this, we might crash
	createGUI(0L);
	guiFactory()->removeClient(detachedView->msgManager());

	if( newWindowIndex == -1 )
		newWindow = new KopeteChatWindow();
	else
		newWindow = windows.at( newWindowIndex );

	newWindow->show();
	newWindow->raise();

	detachChatView( detachedView );
	newWindow->attachChatView( detachedView );
}

void KopeteChatWindow::slotPreviousTab()
{
	int curPage = m_tabBar->currentPageIndex();
	if( curPage > 0 )
		m_tabBar->setCurrentPage( curPage - 1 );
	else
		m_tabBar->setCurrentPage( m_tabBar->count() - 1 );
}

void KopeteChatWindow::slotNextTab()
{
	int curPage = m_tabBar->currentPageIndex();
	if( curPage == ( m_tabBar->count() - 1 ) )
		m_tabBar->setCurrentPage( 0 );
	else
		m_tabBar->setCurrentPage( curPage + 1 );
}

void KopeteChatWindow::slotSetCaption( bool active )
{
	if( active && m_activeView )
	{
		setCaption( m_activeView->caption(), false );
	}
}

void KopeteChatWindow::updateBackground( const QPixmap &pm )
{
	if( updateBg )
	{
		updateBg = false;
		if( backgroundFile != 0L )
		{
			backgroundFile->close();
			backgroundFile->unlink();
		}

		backgroundFile = new KTempFile( QString::null, QString::fromLatin1( ".bmp" ) );
		pm.save( backgroundFile->name(), "BMP" );
		QTimer::singleShot( 100, this, SLOT( slotEnableUpdateBg() ) );
	}
}

void KopeteChatWindow::setActiveView( QWidget *widget )
{
	ChatView *view = static_cast<ChatView*>(widget);

	if( m_activeView == view )
		return;

	if(m_activeView)
	{
		disconnect( m_activeView, SIGNAL( canSendChanged(bool) ), this, SLOT( slotUpdateSendEnabled() ) );
		guiFactory()->removeClient(m_activeView->msgManager());
	}

	guiFactory()->addClient(view->msgManager());
	createGUI( view->part() );

	if( m_activeView )
		m_activeView->setActive( false );

	m_activeView = view;

	if( !chatViewList.contains( view ) )
		attachChatView( view );

	connect( m_activeView, SIGNAL( canSendChanged(bool) ), this, SLOT( slotUpdateSendEnabled() ) );

	//Tell it it is active
	m_activeView->setActive( true );

	//Update icons to match
	slotUpdateCaptionIcons( m_activeView );

	//Update chat members actions
	updateMembersActions();

	if ( m_activeView->sendInProgress() && !animIcon.isNull() )
	{
		anim->setMovie( animIcon );
		animIcon.unpause();
	}
	else
	{
		anim->setPixmap( normalIcon );
		if( !animIcon.isNull() )
			animIcon.pause();
	}

	if ( m_alwaysShowTabs || chatViewList.count() > 1 )
	{
		if( !m_tabBar )
			createTabBar();

		m_tabBar->showPage( m_activeView );
	}

	setCaption( m_activeView->caption() );
	setStatus( m_activeView->statusText() );
	m_activeView->setFocus();

	slotUpdateSendEnabled();
}

void KopeteChatWindow::slotUpdateCaptionIcons( const ChatView *view )
{
	if(!view||!m_activeView||view!=m_activeView )
		return; //(pas de charité)
	QPtrList<Kopete::Contact> chatMembers=view->msgManager()->members();
	Kopete::Contact *c=0L;
	for ( Kopete::Contact *contact = chatMembers.first(); contact; contact = chatMembers.next() )
	{
		if(!c || c->onlineStatus() < contact->onlineStatus())
			c=contact;
	}
	QPixmap icon16 = c ? view->msgManager()->contactOnlineStatus( c ).iconFor( c , 16) : SmallIcon( view->msgManager()->protocol()->pluginIcon() );
	QPixmap icon32 = c ? view->msgManager()->contactOnlineStatus( c ).iconFor( c , 32) : SmallIcon( view->msgManager()->protocol()->pluginIcon() );

	KWin::setIcons( winId(), icon32, icon16 );
}

void KopeteChatWindow::slotChatClosed()
{
	if( m_popupView )
		m_popupView->closeView();
	else
		m_activeView->closeView();
}

void KopeteChatWindow::slotPrepareDetachMenu(void)
{
	QPopupMenu *detachMenu = actionDetachMenu->popupMenu();
	detachMenu->clear();

	for ( unsigned id=0; id < windows.count(); id++ )
	{
		KopeteChatWindow *win = windows.at( id );
		if( win != this )
			detachMenu->insertItem( win->caption(), id );
	}
}

void KopeteChatWindow::slotSendMessage()
{
	if ( m_activeView && m_activeView->canSend() )
	{
		if( !animIcon.isNull() )
		{
			anim->setMovie( animIcon );
			animIcon.unpause();
		}
		m_activeView->sendMessage();
	}
}

void KopeteChatWindow::slotPrepareContactMenu(void)
{
	QPopupMenu *contactsMenu = actionContactMenu->popupMenu();
	contactsMenu->clear();

	Kopete::Contact *contact;
	Kopete::ContactPtrList m_them;

	if( m_popupView )
		m_them = m_popupView->msgManager()->members();
	else
		m_them = m_activeView->msgManager()->members();

	//TODO: don't display a menu with one contact in it, display that
	// contact's menu instead. Will require changing text and icon of
	// 'Contacts' action, or something cleverer.
	uint contactCount = 0;

	for ( contact = m_them.first(); contact; contact = m_them.next() )
	{
		KPopupMenu *p = contact->popupMenu();
		connect ( actionContactMenu->popupMenu(), SIGNAL(aboutToHide()),
			p, SLOT(deleteLater() ) );

		if( contact->metaContact() )
			contactsMenu->insertItem( contact->onlineStatus().iconFor( contact ) , contact->metaContact()->displayName(), p );
		else
			contactsMenu->insertItem( contact->onlineStatus().iconFor( contact ) , contact->contactId(), p );

		//FIXME: This number should be a config option
		if( ++contactCount == 15 && contact != m_them.getLast() )
		{
			KActionMenu *moreMenu = new KActionMenu( i18n("More..."),
				 QString::fromLatin1("folder_open"), contactsMenu );
			connect ( actionContactMenu->popupMenu(), SIGNAL(aboutToHide()),
				moreMenu, SLOT(deleteLater() ) );
			moreMenu->plug( contactsMenu );
			contactsMenu = moreMenu->popupMenu();
			contactCount = 0;
		}
	}
}

void KopeteChatWindow::slotPreparePlacementMenu()
{
	QPopupMenu *placementMenu = actionTabPlacementMenu->popupMenu();
	placementMenu->clear();

	placementMenu->insertItem( i18n("Top"), 0 );
	placementMenu->insertItem( i18n("Bottom"), 1 );
}

void KopeteChatWindow::slotPlaceTabs( int placement )
{
	if( m_tabBar )
	{

		if( placement == 0 )
			m_tabBar->setTabPosition( QTabWidget::Top );
		else
			m_tabBar->setTabPosition( QTabWidget::Bottom );

		saveOptions();
	}
}

void KopeteChatWindow::readOptions()
{
	// load and apply config file settings affecting the appearance of the UI
//	kdDebug(14010) << k_funcinfo << endl;
	KConfig *config = KGlobal::config();
	applyMainWindowSettings( config, QString::fromLatin1( "KopeteChatWindow" ) );
	config->setGroup( QString::fromLatin1("ChatWindowSettings") );
}

void KopeteChatWindow::saveOptions()
{
//	kdDebug(14010) << k_funcinfo << endl;

	KConfig *config = KGlobal::config();

	// saves menubar,toolbar and statusbar setting
	saveMainWindowSettings( config, QString::fromLatin1( "KopeteChatWindow" ) );
	config->setGroup( QString::fromLatin1("ChatWindowSettings") );
	if( m_tabBar )
		config->writeEntry ( QString::fromLatin1("Tab Placement"), m_tabBar->tabPosition() );

	config->sync();
}

void KopeteChatWindow::slotChatSave()
{
//	kdDebug(14010) << "KopeteChatWindow::slotChatSave()" << endl;
	if( isActiveWindow() && m_activeView )
		m_activeView->messagePart()->save();
}

void KopeteChatWindow::windowActivationChange( bool )
{
	if( isActiveWindow() && m_activeView )
		m_activeView->setActive( true );
}

void KopeteChatWindow::slotChatPrint()
{
	m_activeView->messagePart()->print();
}

void KopeteChatWindow::slotToggleStatusBar()
{
	if (statusBar()->isVisible())
		statusBar()->hide();
	else
		statusBar()->show();
}

void KopeteChatWindow::slotViewMenuBar()
{
	if( !menuBar()->isHidden() )
		menuBar()->hide();
	else
		menuBar()->show();
}

void KopeteChatWindow::slotSmileyActivated(const QString &sm)
{
	if ( !sm.isNull() )
		m_activeView->addText( sm );
}

bool KopeteChatWindow::queryClose()
{
	bool canClose = true;

//	kdDebug( 14010 ) << " Windows left open:" << endl;
//	for( QPtrListIterator<ChatView> it( chatViewList ); it; ++it)
//		kdDebug( 14010 ) << "  " << *it << " (" << (*it)->caption() << ")" << endl;

	for( QPtrListIterator<ChatView> it( chatViewList ); it; )
	{
		ChatView *view = *it;
		// move out of the way before view is removed
		++it;

		// FIXME: This should only check if it *can* close
		// and not start closing if the close can be aborted halfway, it would
		// leave us with half the chats open and half of them closed. - Martijn

		// if the view is closed, it is removed from chatViewList for us
		if ( !view->closeView() )
		{
			kdDebug() << k_funcinfo << "Closing view failed!" << endl;
			canClose = false;
		}
	}
	return canClose;
}

bool KopeteChatWindow::queryExit()
{
	KopeteApplication *app = static_cast<KopeteApplication *>( kapp );
 	if ( app->sessionSaving()
		|| app->isShuttingDown() /* only set if KopeteApplication::quitKopete() or
									KopeteApplication::commitData() called */
		|| !KopetePrefs::prefs()->showTray() /* also close if our tray icon is hidden! */
		|| !isShown() )
	{
		Kopete::PluginManager::self()->shutdown();
		return true;
	}
	else 
		return false;
}

void KopeteChatWindow::closeEvent( QCloseEvent * e )
{
	// if there's a system tray applet and we are not shutting down then just do what needs to be done if a
	// window is closed.
	KopeteApplication *app = static_cast<KopeteApplication *>( kapp );
	if ( KopetePrefs::prefs()->showTray() && !app->isShuttingDown() && !app->sessionSaving() ) {
		// BEGIN of code borrowed from KMainWindow::closeEvent
		// Save settings if auto-save is enabled, and settings have changed
		if ( settingsDirty() && autoSaveSettings() )
			saveAutoSaveSettings();
	
		if ( queryClose() ) {
			e->accept();
		}
		// END of code borrowed from KMainWindow::closeEvent
	}
	else
		KMainWindow::closeEvent( e );
}

void KopeteChatWindow::slotConfKeys()
{
	KKeyDialog dlg( false, this );
	dlg.insert( actionCollection() );
	if( m_activeView )
	{
		dlg.insert(m_activeView->msgManager()->actionCollection() , i18n("Plugin Actions") );
		QPtrListIterator<KXMLGUIClient> it( *m_activeView->msgManager()->childClients() );
		KXMLGUIClient *c = 0;
		while( (c = it.current()) != 0 )
		{
			dlg.insert( c->actionCollection() /*, i18n("Plugin Actions")*/ );
			++it;
		}

		if( m_activeView->part() )
			dlg.insert( m_activeView->part()->actionCollection(), m_activeView->part()->name() );
	}

	dlg.configure();
}

void KopeteChatWindow::slotConfToolbar()
{
	saveMainWindowSettings(KGlobal::config(), QString::fromLatin1( "KopeteChatWindow" ));
	KEditToolbar *dlg = new KEditToolbar(factory(), this );
	if (dlg->exec())
	{
		if( m_activeView )
		{
			createGUI( m_activeView->part() );
			//guiFactory()->addClient(m_activeView->msgManager());
		}
		else
			createGUI( 0L );
		applyMainWindowSettings(KGlobal::config(), QString::fromLatin1( "KopeteChatWindow" ));
	}
	delete dlg;
}

#include "kopetechatwindow.moc"

// vim: set noet ts=4 sts=4 sw=4:





class KToggleAction;
class KActionMenu;
class KTempFile;
class KComboBox;
class QPixmap;
class QTabWidget;
class KSqueezedTextLabel;

	void addTab( ChatView* );
	void setPrimaryChatView( ChatView* );
	const QString fileContents( const QString &file ) const;
    void initEncodings();

	ChatView *m_activeView;
	ChatView *m_popupView;

	QLabel *anim;
	QMovie animIcon;
	QPixmap normalIcon;
	KComboBox* m_encoding;

	KAction *chatSend;
	KAction *historyUp;

	void slotStopAnimation( ChatView* );
	void slotNickComplete();
	void slotCloseChat( QWidget* );
    void slotEncodingSelected(const QString& string);

protected:
	virtual void closeEvent( QCloseEvent *e );




/*
    kopetechatwindow.h - Chat Window

    Copyright (c) 2002      by Olivier Goffart        <ogoffart@tiscalinet.be>
    Copyright (c) 2004      by Martijn Klingens       <klingens@kde.org>

    Kopete    (c) 2002-2004 by the Kopete developers  <kopete-devel@kde.org>

    *************************************************************************
    *                                                                       *
    * 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 option) any later version.                                   *
    *                                                                       *
    *************************************************************************
*/

#ifndef KOPETECHATWINDOW_H
#define KOPETECHATWINDOW_H

#include <kparts/mainwindow.h>
#include <qmovie.h>
#include "kopetecontact.h"
#include "kdeversion.h"

class KAction;
class KToggleAction;
class KActionMenu;
class KTempFile;
class QPixmap;
class QTabWidget;
class KSqueezedTextLabel;
class KPushButton;
class QVBox;
class QVBoxLayout;
class QFrame;
class KTabWidget;
class QLabel;
class KopeteEmoticonAction;
class KopeteView;
class KSelectAction;
class ChatView;

namespace Kopete
{
class Message;
class ChatSession;
class Contact;
class Protocol;
typedef QPtrList<Contact>  ContactPtrList;
}

class KopeteChatWindow : public KParts::MainWindow
{
	Q_OBJECT

	enum {NEW_WINDOW, GROUP_BY_ACCOUNT, GROUP_ALL, GROUP_BY_GROUP, GROUP_BY_METACONTACT};

public:
	/**
	 * Find the appropriate window for a ChatView of the given protocol to
	 * dock into. If no such window exists, create one.
	 * @param protocol The protocol we are creating a view for
	 * @return A KopeteChatWindow suitable for docking a ChatView into. Guaranteed
	 *  to be a valid pointer.
	 */
	static KopeteChatWindow *window( Kopete::ChatSession *manager );
	~KopeteChatWindow();

	/**
	 * Attach an unattached chatview to this window
	 * @param chat The chat view to attach
	 */
	void attachChatView( ChatView *chat );

	/**
	 * Detach a chat view from this window
	 * @param chat The chat view to detach
	 */
	void detachChatView( ChatView *chat );

	/**
	 * Returns the number of chat views attached to this window
	 */
	const int chatViewCount() { return chatViewList.count(); }

	/**
	 * Returns the chatview in the currently active tab, or the only chat view
	 * if chatViewCount() == 1
	 */
	ChatView *activeView();

	void updateMembersActions();
	void setStatus( const QString & );

	/** 
	 * Reimplemented from KMainWindow - asks each ChatView in the window if it is ok to close the window 
	 * @return true if no ChatView objects to closing.
	 */
	virtual bool queryClose();
	virtual bool queryExit();

	KTempFile *backgroundFile;
	QPtrList<ChatView> chatViewList;

private:
	// All KopeteChatWindows are created by the findWindow function
	KopeteChatWindow( QWidget *parent = 0, const char* name = "KopeteChatWindow" );

	/**
	 * The window list has changed:
	 * For each chat window, update it's Move Tab to Window action
	 */
	static void windowListChanged();

	void initActions(void);
	void saveOptions(void);
	void readOptions(void);
	void checkDetachEnable();
	void createTabBar();
	void deleteTabBar();
	void addTab( ChatView* );
	void setPrimaryChatView( ChatView* );
	const QString fileContents( const QString &file ) const;

	ChatView *m_activeView;
	ChatView *m_popupView;
	bool m_alwaysShowTabs;
	bool updateBg;
	KTabWidget *m_tabBar;
	KPushButton *m_button_send;
	KSqueezedTextLabel *m_status_text;
	QVBoxLayout *mainLayout;
	QFrame *mainArea;
	QLabel *anim;
	QMovie animIcon;
	QPixmap normalIcon;

	KAction *chatSend;
	KAction *historyUp;
	KAction *historyDown;
	KAction *nickComplete;

#if !KDE_IS_VERSION( 3, 1, 90 )
	KToggleAction *mStatusbarAction;
#endif

	KAction *tabLeft;
	KAction *tabRight;
	KAction *tabDetach;
	KAction* tabClose;

	KToggleAction* membersLeft;
	KToggleAction* membersRight;
	KToggleAction* toggleMembers;

	KopeteEmoticonAction *actionSmileyMenu;
	KActionMenu *actionActionMenu;
	KActionMenu *actionContactMenu;
	KActionMenu *actionDetachMenu;
	KActionMenu *actionTabPlacementMenu;
	QString statusMsg;

signals:
	void closing( KopeteChatWindow* );

public slots:
	void slotSmileyActivated( const QString & );
	void setActiveView( QWidget *active );
	void updateBackground( const QPixmap &pm );

private slots:
//	void slotPrepareSmileyMenu();
	void slotPrepareContactMenu();
	void slotPrepareDetachMenu();
	void slotPreparePlacementMenu();
	void slotUpdateSendEnabled();

	void slotCut();
	void slotCopy();
	void slotPaste();

	void slotSetBgColor();
	void slotSetFgColor();
	void slotSetFont();

	void slotHistoryUp();
	void slotHistoryDown();
	void slotPageUp();
	void slotPageDown();

	void slotSendMessage();
	void slotChatSave();
	void slotChatPrint();

	void slotPreviousTab();
	void slotNextTab();
	void slotDetachChat( int newWindowIndex = -1 );
	void slotPlaceTabs( int tabPlacement );

	void slotViewMenuBar();
	void slotToggleStatusBar();

	void slotConfKeys();
	void slotConfToolbar();

	void slotViewMembersLeft();
	void slotViewMembersRight();
	void slotToggleViewMembers();
	void slotEnableUpdateBg() { updateBg = true; }

	void slotSetCaption( bool );
	void slotUpdateCaptionIcons( const ChatView * );
	void slotChatClosed();
	void slotTabContextMenu( QWidget*, const QPoint & );
	void slotStopAnimation( ChatView* );
	void slotNickComplete();
	void slotCloseChat( QWidget* );

protected:
	virtual void closeEvent( QCloseEvent *e );
	virtual void windowActivationChange( bool );
};

#endif

// vim: set noet ts=4 sts=4 sw=4:


Lines 84-90 QStringList KopeteIface::contactFileProt Link Here

(-)../work-orig/kopete-3.4.0/kopete/kopete/kopeteiface.cpp (-1 lines)
84	{	84	{
85	return Kopete::ContactList::self()->contactFileProtocols(displayName);	85	return Kopete::ContactList::self()->contactFileProtocols(displayName);
86	}	86	}
87
88	QString KopeteIface::messageContact( const QString &contactId, const QString &messageText )	87	QString KopeteIface::messageContact( const QString &contactId, const QString &messageText )
89	{	88	{
90	Kopete::MetaContact *mc = Kopete::ContactList::self()->findMetaContactByContactId( contactId );	89	Kopete::MetaContact *mc = Kopete::ContactList::self()->findMetaContactByContactId( contactId );

Lines 19-24 Link Here

(-)../work-orig/kopete-3.4.0/kopete/kopete/systemtray.cpp (-1 / +20 lines)
19		19
20	#include "systemtray.h"	20	#include "systemtray.h"
21		21
		22	#include <qtextcodec.h>
22	#include <qtimer.h>	23	#include <qtimer.h>
23	#include <qtooltip.h>	24	#include <qtooltip.h>
24	#include <qregexp.h>	25	#include <qregexp.h>
Lines 29-34 Link Here
29	#include <kapplication.h>	30	#include <kapplication.h>
30	#include <kdebug.h>	31	#include <kdebug.h>
31	#include <kiconloader.h>	32	#include <kiconloader.h>
		33	#include <kconfig.h>
		34
32	#include "kopeteuiglobal.h"	35	#include "kopeteuiglobal.h"
33	#include "kopetemessagemanagerfactory.h"	36	#include "kopetemessagemanagerfactory.h"
34	#include "kopeteballoon.h"	37	#include "kopeteballoon.h"
Lines 258-267 void KopeteSystemTray::addBalloon() Link Here
258	msgFrom = msg.from()->metaContact()->displayName();	261	msgFrom = msg.from()->metaContact()->displayName();
259	else	262	else
260	msgFrom = msg.from()->contactId();	263	msgFrom = msg.from()->contactId();
261		264
		265	KConfig* cf=KGlobal::config();
		266	QString uid=msg.from()->contactId();
		267	QString gr=cf->group();
		268	cf->setGroup("Encodings");
		269	QString codepage=cf->readEntry(uid,"Unicode");
		270	cf->setGroup(gr);
		271	if(codepage != "Unicode")
		272	{
		273	QCString locallyEncoded = msgText.ascii();
		274	QTextCodec *codec = QTextCodec::codecForName(codepage.ascii());
		275	if(codec)
		276	msgText=codec->toUnicode( locallyEncoded );
		277	}
		278
262	m_balloon = new KopeteBalloon(	279	m_balloon = new KopeteBalloon(
263	i18n( "<qt><nobr><b>New Message from %1:</b></nobr><br><nobr>\"%2\"</nobr></qt>" )	280	i18n( "<qt><nobr><b>New Message from %1:</b></nobr><br><nobr>\"%2\"</nobr></qt>" )
264	.arg( msgFrom, msgText ), QString::null );	281	.arg( msgFrom, msgText ), QString::null );
		282	kdDebug()<<"baloon from "<<msgFrom<<" with test "<<
		283	msgText<<endl;
265	connect(m_balloon, SIGNAL(signalBalloonClicked()), mEventList.first() , SLOT(apply()));	284	connect(m_balloon, SIGNAL(signalBalloonClicked()), mEventList.first() , SLOT(apply()));
266	connect(m_balloon, SIGNAL(signalButtonClicked()), mEventList.first() , SLOT(apply()));	285	connect(m_balloon, SIGNAL(signalButtonClicked()), mEventList.first() , SLOT(apply()));
267	connect(m_balloon, SIGNAL(signalIgnoreButtonClicked()), mEventList.first() , SLOT(ignore()));	286	connect(m_balloon, SIGNAL(signalIgnoreButtonClicked()), mEventList.first() , SLOT(ignore()));




/*
    systemtray.cpp  -  Kopete Tray Dock Icon

    Copyright (c) 2002      by Nick Betcher           <nbetcher@kde.org>
    Copyright (c) 2002-2003 by Martijn Klingens       <klingens@kde.org>
    Copyright (c) 2003-2004 by Olivier Goffart        <ogoffart@tiscalinet.be>

    Kopete    (c) 2002-2004 by the Kopete developers  <kopete-devel@kde.org>

    *************************************************************************
    *                                                                       *
    * 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 option) any later version.                                   *
    *                                                                       *
    *************************************************************************
*/

#include "systemtray.h"

#include <qtimer.h>
#include <qtooltip.h>
#include <qregexp.h>

#include <kwin.h>
#include <kaboutdata.h>
#include <kactioncollection.h>
#include <kapplication.h>
#include <kdebug.h>
#include <kiconloader.h>
#include "kopeteuiglobal.h"
#include "kopetemessagemanagerfactory.h"
#include "kopeteballoon.h"
#include "kopeteprefs.h"
#include "kopetemetacontact.h"
#include "kopeteaccount.h"
#include "kopeteaccountmanager.h"
#include "kopetecontact.h"
#include "kopetewindow.h"

KopeteSystemTray* KopeteSystemTray::s_systemTray = 0L;

KopeteSystemTray* KopeteSystemTray::systemTray( QWidget *parent, const char* name )
{
	if( !s_systemTray )
		s_systemTray = new KopeteSystemTray( parent, name );

	return s_systemTray;
}

KopeteSystemTray::KopeteSystemTray(QWidget* parent, const char* name)
	: KSystemTray(parent,name)
{
//	kdDebug(14010) << "Creating KopeteSystemTray" << endl;
	QToolTip::add( this, kapp->aboutData()->shortDescription() );

	mIsBlinkIcon = false;
	mIsBlinking = false;
	mBlinkTimer = new QTimer(this, "mBlinkTimer");

	mKopeteIcon = loadIcon("kopete");

	connect(mBlinkTimer, SIGNAL(timeout()), this, SLOT(slotBlink()));
	connect(Kopete::ChatSessionManager::self() , SIGNAL(newEvent(Kopete::MessageEvent*)),
		this, SLOT(slotNewEvent(Kopete::MessageEvent*)));
	connect(KopetePrefs::prefs(), SIGNAL(saved()), this, SLOT(slotConfigChanged()));

	connect(Kopete::AccountManager::self(),
		SIGNAL(accountOnlineStatusChanged(Kopete::Account *,
		const Kopete::OnlineStatus &, const Kopete::OnlineStatus &)),
	this, SLOT(slotReevaluateAccountStates()));

	// the slot called by default by the quit action, KSystemTray::maybeQuit(),
	// just closes the parent window, which is hard to distinguish in that window's closeEvent()
	// from a click on the window's close widget
	// in the quit case, we want to quit the application
 	// in the close widget click case, we only want to hide the parent window
	// so instead, we make it call our general purpose quit slot on the window, which causes a window close and everything else we need
	// KDE4 - app will have to listen for quitSelected instead
	KAction *quit = actionCollection()->action( "file_quit" );
	quit->disconnect();
	KopeteWindow *myParent = static_cast<KopeteWindow *>( parent );
    connect( quit, SIGNAL( activated() ), myParent, SLOT( slotQuit() ) );

	//setPixmap(mKopeteIcon);
	slotReevaluateAccountStates();
	slotConfigChanged();

	m_balloon=0l;
}

KopeteSystemTray::~KopeteSystemTray()
{
//	kdDebug(14010) << "[KopeteSystemTray] ~KopeteSystemTray" << endl;
//	delete mBlinkTimer;
	Kopete::UI::Global::setSysTrayWId( 0 );
}

void KopeteSystemTray::mousePressEvent( QMouseEvent *me )
{
	if (
		(me->button() == QEvent::MidButton || me->button() == QEvent::LeftButton) &&
		mIsBlinking )
	{
		mouseDoubleClickEvent( me );
		return;
	}

	KSystemTray::mousePressEvent( me );
}

void KopeteSystemTray::mouseDoubleClickEvent( QMouseEvent *me )
{
	if ( !mIsBlinking )
	{
		KSystemTray::mousePressEvent( me );
	}
	else
	{
		if(!mEventList.isEmpty())
			mEventList.first()->apply();
	}
}

void KopeteSystemTray::contextMenuAboutToShow( KPopupMenu *me )
{
	//kdDebug(14010) << k_funcinfo << "Called." << endl;
	emit aboutToShowMenu( me );
}

void KopeteSystemTray::startBlink( const QString &icon )
{
	startBlink( KGlobal::iconLoader()->loadIcon( icon , KIcon::Panel ) );
}

void KopeteSystemTray::startBlink( const QPixmap &icon )
{
	mBlinkIcon = icon;
	if ( mBlinkTimer->isActive() == false )
	{
		mIsBlinkIcon = true;
		mIsBlinking = true;
		mBlinkTimer->start( 1000, false );
	}
	else
	{
		mBlinkTimer->stop();
		mIsBlinkIcon = true;
		mIsBlinking = true;
		mBlinkTimer->start( 1000, false );
	}
}

void KopeteSystemTray::startBlink( const QMovie &movie )
{
	//kdDebug( 14010 ) << k_funcinfo << "starting movie." << endl;
	const_cast<QMovie &>( movie ).unpause();
	setMovie( movie );
	mIsBlinking = true;
}

void KopeteSystemTray::startBlink()
{
	if ( mMovie.isNull() )
		mMovie = KGlobal::iconLoader()->loadMovie( QString::fromLatin1( "newmessage" ), KIcon::Panel );

	startBlink( mMovie );
}

void KopeteSystemTray::stopBlink()
{
	if ( movie() )
		kdDebug( 14010 ) << k_funcinfo << "stopping movie." << endl;
	else if ( mBlinkTimer->isActive() )
		mBlinkTimer->stop();

	if ( !mMovie.isNull() )
		mMovie.pause();

	mIsBlinkIcon = false;
	mIsBlinking = false;
	//setPixmap( mKopeteIcon );
	slotReevaluateAccountStates();
}

void KopeteSystemTray::slotBlink()
{
	setPixmap( mIsBlinkIcon ? mKopeteIcon : mBlinkIcon );

	mIsBlinkIcon = !mIsBlinkIcon;
}

void KopeteSystemTray::slotNewEvent( Kopete::MessageEvent *event )
{
	mEventList.append( event );
	connect(event, SIGNAL(done(Kopete::MessageEvent*)),
		this, SLOT(slotEventDone(Kopete::MessageEvent*)));

	if( event->message().manager() != 0 )
	{
		if( event->message().manager()->account() )
		{
			if( !event->message().manager()->account()->isAway() ||
				KopetePrefs::prefs()->soundIfAway() )
			{
				addBalloon();
			}
			else
			{
				kdDebug(14000) << k_funcinfo << "Supressing balloon, account is away" << endl;
			}
		}
	}
	else
		kdDebug(14000) << k_funcinfo << "NULL message().manager()!" << endl;

	// tray animation
	if ( KopetePrefs::prefs()->trayflashNotify() )
		startBlink();
}

void KopeteSystemTray::slotEventDone(Kopete::MessageEvent *event)
{
	bool current= event==mEventList.first();
	mEventList.remove(event);

	if(current && m_balloon)
	{
		m_balloon->deleteLater();
		m_balloon=0l;
		if(!mEventList.isEmpty())
			addBalloon();
	}

	if(mEventList.isEmpty())
		stopBlink();
}

void KopeteSystemTray::addBalloon()
{
	/*kdDebug(14010) << k_funcinfo <<
		m_balloon << ":" << KopetePrefs::prefs()->showTray() <<
		":" << KopetePrefs::prefs()->balloonNotify()
		<< ":" << !mEventList.isEmpty() << endl;*/

	if( !m_balloon && KopetePrefs::prefs()->showTray() && KopetePrefs::prefs()->balloonNotify() && !mEventList.isEmpty() )
	{
		Kopete::Message msg = mEventList.first()->message();

		if ( msg.from() )
		{
			QString msgText = squashMessage( msg );
			kdDebug(14010) << k_funcinfo << "msg text=" << msgText << endl;

			QString msgFrom;
			if( msg.from()->metaContact() )
				msgFrom = msg.from()->metaContact()->displayName();
			else
				msgFrom = msg.from()->contactId();

			m_balloon = new KopeteBalloon(
				i18n( "<qt><nobr><b>New Message from %1:</b></nobr><br><nobr>\"%2\"</nobr></qt>" )
					.arg( msgFrom, msgText ), QString::null );
			connect(m_balloon, SIGNAL(signalBalloonClicked()), mEventList.first() , SLOT(apply()));
			connect(m_balloon, SIGNAL(signalButtonClicked()), mEventList.first() , SLOT(apply()));
			connect(m_balloon, SIGNAL(signalIgnoreButtonClicked()), mEventList.first() , SLOT(ignore()));
			m_balloon->setAnchor(mapToGlobal(pos()));
			m_balloon->show();
			KWin::setOnAllDesktops(m_balloon->winId(), true);
		}
	}
}

void KopeteSystemTray::slotConfigChanged()
{
//	kdDebug(14010) << k_funcinfo << "called." << endl;
	if ( KopetePrefs::prefs()->showTray() )
		show();
	else
		hide(); // for users without kicker or a similar docking app
}

void KopeteSystemTray::slotReevaluateAccountStates()
{
	// If there is a pending message, we don't need to refresh the system tray now.
	// This function will even be called when the animation will stop.
	if ( mIsBlinking )
		return;

	
	//kdDebug(14010) << k_funcinfo << endl;
	bool bOnline = false;
	bool bAway = false;
	bool bOffline = false;
	Kopete::Contact *c = 0;

	for (QPtrListIterator<Kopete::Account> it(Kopete::AccountManager::self()->accounts()); it.current(); ++it)
	{
		c = it.current()->myself();
		if (!c)
			continue;

		if (c->onlineStatus().status() == Kopete::OnlineStatus::Online)
		{
			bOnline = true; // at least one contact is online
		}
		else if (c->onlineStatus().status() == Kopete::OnlineStatus::Away
		      || c->onlineStatus().status() == Kopete::OnlineStatus::Invisible)
		{
			bAway = true; // at least one contact is away or invisible
		}
		else // this account must be offline (or unknown, which I don't know how to handle)
		{
			bOffline = true;
		}
	}

	if (!bOnline && !bAway && !bOffline) // special case, no accounts defined (yet)
		bOffline = true;

	if (bAway)
	{
		if (!bOnline && !bOffline) // none online and none offline -> all away
			setPixmap(loadIcon("kopete_all_away"));
		else
			setPixmap(loadIcon("kopete_some_away"));
	}
	else if(bOnline)
	{
		/*if(bOffline) // at least one offline and at least one online -> some accounts online
			setPixmap(loadIcon("kopete_some_online"));
		else*/ // none offline and none away -> all online
			setPixmap(mKopeteIcon);
	}
	else // none away and none online -> all offline
	{
		//kdDebug(14010) << k_funcinfo << "All Accounts offline!" << endl;
		setPixmap(loadIcon("kopete_offline"));
	}
}


QString KopeteSystemTray::squashMessage( const Kopete::Message& msg )
{
	QString msgText = msg.parsedBody();

	QRegExp rx( "(<a.*>((http://)?(.+))</a>)" );
	rx.setMinimal( true );
	if ( rx.search( msgText ) == -1 )
	{
		// no URLs in text, just pick the first 30 chars of
		// the parsed text if necessary. We used parsed text
		// so that things like "<knuff>" show correctly
		//  Escape it after snipping it to not snip entities
		msgText =msg.plainBody() ;
		if( msgText.length() > 30 )
			msgText = msgText.left( 30 ) + QString::fromLatin1( " ..." );
		msgText=Kopete::Message::escape(msgText);
	}
	else
	{
		QString plainText = msg.plainBody();
		if ( plainText.length() > 30 )
		{
			QString fullUrl = rx.cap( 2 );
			QString shorterUrl;
			if ( fullUrl.length() > 30 )
			{
				QString urlWithoutProtocol = rx.cap( 4 );
				shorterUrl = urlWithoutProtocol.left( 27 )
						+ QString::fromLatin1( "... " );
			}
			else
			{
				shorterUrl = fullUrl.left( 27 )
						+ QString::fromLatin1( "... " );
			}
			// remove message text
			msgText = QString::fromLatin1( "... " ) +
					rx.cap( 1 ) +
					QString::fromLatin1( " ..." );
			// find last occurrence of URL (the one inside the <a> tag)
			int revUrlOffset = msgText.findRev( fullUrl );
			msgText.replace( revUrlOffset,
						fullUrl.length(), shorterUrl );
		}
	}
	return msgText;
}

#include "systemtray.moc"
// vim: set noet ts=4 sts=4 sw=4:

Return to bug 93052

Lines 55-60 public: Link Here

(-)../work-orig/kopete-3.4.0/kopete/kopete/chatwindow/chatmessagepart.h (-1 / +4 lines)
55	* use	55	* use
56	*/	56	*/
57	void keepScrolledDown();	57	void keepScrolledDown();
		58	void setCodepage(const QString& page);
58		59
59	public slots:	60	public slots:
60	/**	61	/**
Lines 91-97 public slots: Link Here
91	* Appends a message to the messave view	92	* Appends a message to the messave view
92	* @param message The message to be appended	93	* @param message The message to be appended
93	*/	94	*/
94	void appendMessage( Kopete::Message &message );	95	void appendMessage( Kopete::Message &message,bool encode=true );
		96	void slotConvert(const QString& string);
95		97
96	signals:	98	signals:
97	/**	99	/**
Lines 157-162 private: Link Here
157	KAction *printAction;	159	KAction *printAction;
158	KAction *closeAction;	160	KAction *closeAction;
159	KAction *copyURLAction;	161	KAction *copyURLAction;
		162	QString codepage;
160		163
161	void readOverrides();	164	void readOverrides();
162		165

Lines 28-33 class KAction; Link Here

(-)../work-orig/kopete-3.4.0/kopete/kopete/chatwindow/kopetechatwindow.h (+4 lines)
28	class KToggleAction;	28	class KToggleAction;
29	class KActionMenu;	29	class KActionMenu;
30	class KTempFile;	30	class KTempFile;
		31	class KComboBox;
31	class QPixmap;	32	class QPixmap;
32	class QTabWidget;	33	class QTabWidget;
33	class KSqueezedTextLabel;	34	class KSqueezedTextLabel;
Lines 123-128 private: Link Here
123	void addTab( ChatView* );	124	void addTab( ChatView* );
124	void setPrimaryChatView( ChatView* );	125	void setPrimaryChatView( ChatView* );
125	const QString fileContents( const QString &file ) const;	126	const QString fileContents( const QString &file ) const;
		127	void initEncodings();
126		128
127	ChatView *m_activeView;	129	ChatView *m_activeView;
128	ChatView *m_popupView;	130	ChatView *m_popupView;
Lines 136-141 private: Link Here
136	QLabel *anim;	138	QLabel *anim;
137	QMovie animIcon;	139	QMovie animIcon;
138	QPixmap normalIcon;	140	QPixmap normalIcon;
		141	KComboBox* m_encoding;
139		142
140	KAction *chatSend;	143	KAction *chatSend;
141	KAction *historyUp;	144	KAction *historyUp;
Lines 217-222 private slots: Link Here
217	void slotStopAnimation( ChatView* );	220	void slotStopAnimation( ChatView* );
218	void slotNickComplete();	221	void slotNickComplete();
219	void slotCloseChat( QWidget* );	222	void slotCloseChat( QWidget* );
		223	void slotEncodingSelected(const QString& string);
220		224
221	protected:	225	protected:
222	virtual void closeEvent( QCloseEvent *e );	226	virtual void closeEvent( QCloseEvent *e );

Line 0 Link Here

(-)../work-orig/kopete-3.4.0/kopete/kopete/chatwindow/kopetechatwindow.h.orig (+229 lines)
		1	/*
		2	kopetechatwindow.h - Chat Window
		3
		4	Copyright (c) 2002 by Olivier Goffart <ogoffart@tiscalinet.be>
		5	Copyright (c) 2004 by Martijn Klingens <klingens@kde.org>
		6
		7	Kopete (c) 2002-2004 by the Kopete developers <kopete-devel@kde.org>
		8
		9	*************************************************************************
		10	* *
		11	* This program is free software; you can redistribute it and/or modify *
		12	* it under the terms of the GNU General Public License as published by *
		13	* the Free Software Foundation; either version 2 of the License, or *
		14	* (at your option) any later version. *
		15	* *
		16	*************************************************************************
		17	*/
		18
		19	#ifndef KOPETECHATWINDOW_H
		20	#define KOPETECHATWINDOW_H
		21
		22	#include <kparts/mainwindow.h>
		23	#include <qmovie.h>
		24	#include "kopetecontact.h"
		25	#include "kdeversion.h"
		26
		27	class KAction;
		28	class KToggleAction;
		29	class KActionMenu;
		30	class KTempFile;
		31	class QPixmap;
		32	class QTabWidget;
		33	class KSqueezedTextLabel;
		34	class KPushButton;
		35	class QVBox;
		36	class QVBoxLayout;
		37	class QFrame;
		38	class KTabWidget;
		39	class QLabel;
		40	class KopeteEmoticonAction;
		41	class KopeteView;
		42	class KSelectAction;
		43	class ChatView;
		44
		45	namespace Kopete
		46	{
		47	class Message;
		48	class ChatSession;
		49	class Contact;
		50	class Protocol;
		51	typedef QPtrList<Contact> ContactPtrList;
		52	}
		53
		54	class KopeteChatWindow : public KParts::MainWindow
		55	{
		56	Q_OBJECT
		57
		58	enum {NEW_WINDOW, GROUP_BY_ACCOUNT, GROUP_ALL, GROUP_BY_GROUP, GROUP_BY_METACONTACT};
		59
		60	public:
		61	/**
		62	* Find the appropriate window for a ChatView of the given protocol to
		63	* dock into. If no such window exists, create one.
		64	* @param protocol The protocol we are creating a view for
65	* @return A KopeteChatWindow suitable for docking a ChatView into. Guaranteed
66	* to be a valid pointer.
67	*/
68	static KopeteChatWindow window( Kopete::ChatSession manager );
69	~KopeteChatWindow();
70
71	/**
72	* Attach an unattached chatview to this window
73	* @param chat The chat view to attach
74	*/
75	void attachChatView( ChatView *chat );
76
77	/**
78	* Detach a chat view from this window
79	* @param chat The chat view to detach
80	*/
81	void detachChatView( ChatView *chat );
82
83	/**
84	* Returns the number of chat views attached to this window
85	*/
86	const int chatViewCount() { return chatViewList.count(); }
87
88	/**
89	* Returns the chatview in the currently active tab, or the only chat view
90	* if chatViewCount() == 1
91	*/
92	ChatView *activeView();
93
94	void updateMembersActions();
95	void setStatus( const QString & );
96
97	/**
98	* Reimplemented from KMainWindow - asks each ChatView in the window if it is ok to close the window
99	* @return true if no ChatView objects to closing.
100	*/
101	virtual bool queryClose();
102	virtual bool queryExit();
103
104	KTempFile *backgroundFile;
105	QPtrList<ChatView> chatViewList;
106
107	private:
108	// All KopeteChatWindows are created by the findWindow function
109	KopeteChatWindow( QWidget parent = 0, const char name = "KopeteChatWindow" );
110
111	/**
112	* The window list has changed:
113	* For each chat window, update it's Move Tab to Window action
114	*/
115	static void windowListChanged();
116
117	void initActions(void);
118	void saveOptions(void);
119	void readOptions(void);
120	void checkDetachEnable();
121	void createTabBar();
122	void deleteTabBar();
123	void addTab( ChatView* );
124	void setPrimaryChatView( ChatView* );
125	const QString fileContents( const QString &file ) const;
126
127	ChatView *m_activeView;
128	ChatView *m_popupView;
129	bool m_alwaysShowTabs;
130	bool updateBg;
131	KTabWidget *m_tabBar;
132	KPushButton *m_button_send;
133	KSqueezedTextLabel *m_status_text;
134	QVBoxLayout *mainLayout;
135	QFrame *mainArea;
136	QLabel *anim;
137	QMovie animIcon;
138	QPixmap normalIcon;
139
140	KAction *chatSend;
141	KAction *historyUp;
142	KAction *historyDown;
143	KAction *nickComplete;
144
145	#if !KDE_IS_VERSION( 3, 1, 90 )
146	KToggleAction *mStatusbarAction;
147	#endif
148
149	KAction *tabLeft;
150	KAction *tabRight;
151	KAction *tabDetach;
152	KAction* tabClose;
153
154	KToggleAction* membersLeft;
155	KToggleAction* membersRight;
156	KToggleAction* toggleMembers;
157
158	KopeteEmoticonAction *actionSmileyMenu;
159	KActionMenu *actionActionMenu;
160	KActionMenu *actionContactMenu;
161	KActionMenu *actionDetachMenu;
162	KActionMenu *actionTabPlacementMenu;
163	QString statusMsg;
164
165	signals:
166	void closing( KopeteChatWindow* );
167
168	public slots:
169	void slotSmileyActivated( const QString & );
170	void setActiveView( QWidget *active );
171	void updateBackground( const QPixmap &pm );
172
173	private slots:
174	// void slotPrepareSmileyMenu();
175	void slotPrepareContactMenu();
176	void slotPrepareDetachMenu();
177	void slotPreparePlacementMenu();
178	void slotUpdateSendEnabled();
179
180	void slotCut();
181	void slotCopy();
182	void slotPaste();
183
184	void slotSetBgColor();
185	void slotSetFgColor();
186	void slotSetFont();
187
188	void slotHistoryUp();
189	void slotHistoryDown();
190	void slotPageUp();
191	void slotPageDown();
192
193	void slotSendMessage();
194	void slotChatSave();
195	void slotChatPrint();
196
197	void slotPreviousTab();
198	void slotNextTab();
199	void slotDetachChat( int newWindowIndex = -1 );
200	void slotPlaceTabs( int tabPlacement );
201
202	void slotViewMenuBar();
203	void slotToggleStatusBar();
204
205	void slotConfKeys();
206	void slotConfToolbar();
207
208	void slotViewMembersLeft();
209	void slotViewMembersRight();
210	void slotToggleViewMembers();
211	void slotEnableUpdateBg() { updateBg = true; }
212
213	void slotSetCaption( bool );
214	void slotUpdateCaptionIcons( const ChatView * );
215	void slotChatClosed();
216	void slotTabContextMenu( QWidget*, const QPoint & );
217	void slotStopAnimation( ChatView* );
218	void slotNickComplete();
219	void slotCloseChat( QWidget* );
220
221	protected:
222	virtual void closeEvent( QCloseEvent *e );
223	virtual void windowActivationChange( bool );
224	};
225
226	#endif
227
228	// vim: set noet ts=4 sts=4 sw=4:
229

Line 0 Link Here

(-)../work-orig/kopete-3.4.0/kopete/kopete/systemtray.cpp.orig (+393 lines)
		1	/*
		2	systemtray.cpp - Kopete Tray Dock Icon
		3
		4	Copyright (c) 2002 by Nick Betcher <nbetcher@kde.org>
		5	Copyright (c) 2002-2003 by Martijn Klingens <klingens@kde.org>
		6	Copyright (c) 2003-2004 by Olivier Goffart <ogoffart@tiscalinet.be>
		7
		8	Kopete (c) 2002-2004 by the Kopete developers <kopete-devel@kde.org>
		9
		10	*************************************************************************
		11	* *
		12	* This program is free software; you can redistribute it and/or modify *
		13	* it under the terms of the GNU General Public License as published by *
		14	* the Free Software Foundation; either version 2 of the License, or *
		15	* (at your option) any later version. *
		16	* *
		17	*************************************************************************
		18	*/
		19
		20	#include "systemtray.h"
		21
		22	#include <qtimer.h>
		23	#include <qtooltip.h>
		24	#include <qregexp.h>
		25
		26	#include <kwin.h>
		27	#include <kaboutdata.h>
		28	#include <kactioncollection.h>
		29	#include <kapplication.h>
		30	#include <kdebug.h>
		31	#include <kiconloader.h>
		32	#include "kopeteuiglobal.h"
		33	#include "kopetemessagemanagerfactory.h"
		34	#include "kopeteballoon.h"
		35	#include "kopeteprefs.h"
		36	#include "kopetemetacontact.h"
		37	#include "kopeteaccount.h"
		38	#include "kopeteaccountmanager.h"
		39	#include "kopetecontact.h"
		40	#include "kopetewindow.h"
		41
		42	KopeteSystemTray* KopeteSystemTray::s_systemTray = 0L;
		43
		44	KopeteSystemTray* KopeteSystemTray::systemTray( QWidget parent, const char name )
		45	{
		46	if( !s_systemTray )
		47	s_systemTray = new KopeteSystemTray( parent, name );
		48
		49	return s_systemTray;
		50	}
		51
		52	KopeteSystemTray::KopeteSystemTray(QWidget* parent, const char* name)
		53	: KSystemTray(parent,name)
		54	{
		55	// kdDebug(14010) << "Creating KopeteSystemTray" << endl;
		56	QToolTip::add( this, kapp->aboutData()->shortDescription() );
		57
		58	mIsBlinkIcon = false;
		59	mIsBlinking = false;
		60	mBlinkTimer = new QTimer(this, "mBlinkTimer");
		61
		62	mKopeteIcon = loadIcon("kopete");
		63
		64	connect(mBlinkTimer, SIGNAL(timeout()), this, SLOT(slotBlink()));
65	connect(Kopete::ChatSessionManager::self() , SIGNAL(newEvent(Kopete::MessageEvent*)),
66	this, SLOT(slotNewEvent(Kopete::MessageEvent*)));
67	connect(KopetePrefs::prefs(), SIGNAL(saved()), this, SLOT(slotConfigChanged()));
68
69	connect(Kopete::AccountManager::self(),
70	SIGNAL(accountOnlineStatusChanged(Kopete::Account *,
71	const Kopete::OnlineStatus &, const Kopete::OnlineStatus &)),
72	this, SLOT(slotReevaluateAccountStates()));
73
74	// the slot called by default by the quit action, KSystemTray::maybeQuit(),
75	// just closes the parent window, which is hard to distinguish in that window's closeEvent()
76	// from a click on the window's close widget
77	// in the quit case, we want to quit the application
78	// in the close widget click case, we only want to hide the parent window
79	// so instead, we make it call our general purpose quit slot on the window, which causes a window close and everything else we need
80	// KDE4 - app will have to listen for quitSelected instead
81	KAction *quit = actionCollection()->action( "file_quit" );
82	quit->disconnect();
83	KopeteWindow myParent = static_cast<KopeteWindow >( parent );
84	connect( quit, SIGNAL( activated() ), myParent, SLOT( slotQuit() ) );
85
86	//setPixmap(mKopeteIcon);
87	slotReevaluateAccountStates();
88	slotConfigChanged();
89
90	m_balloon=0l;
91	}
92
93	KopeteSystemTray::~KopeteSystemTray()
94	{
95	// kdDebug(14010) << "[KopeteSystemTray] ~KopeteSystemTray" << endl;
96	// delete mBlinkTimer;
97	Kopete::UI::Global::setSysTrayWId( 0 );
98	}
99
100	void KopeteSystemTray::mousePressEvent( QMouseEvent *me )
101	{
102	if (
103	(me->button() == QEvent::MidButton \|\| me->button() == QEvent::LeftButton) &&
104	mIsBlinking )
105	{
106	mouseDoubleClickEvent( me );
107	return;
108	}
109
110	KSystemTray::mousePressEvent( me );
111	}
112
113	void KopeteSystemTray::mouseDoubleClickEvent( QMouseEvent *me )
114	{
115	if ( !mIsBlinking )
116	{
117	KSystemTray::mousePressEvent( me );
118	}
119	else
120	{
121	if(!mEventList.isEmpty())
122	mEventList.first()->apply();
123	}
124	}
125
126	void KopeteSystemTray::contextMenuAboutToShow( KPopupMenu *me )
127	{
128	//kdDebug(14010) << k_funcinfo << "Called." << endl;
129	emit aboutToShowMenu( me );
130	}
131
132	void KopeteSystemTray::startBlink( const QString &icon )
133	{
134	startBlink( KGlobal::iconLoader()->loadIcon( icon , KIcon::Panel ) );
135	}
136
137	void KopeteSystemTray::startBlink( const QPixmap &icon )
138	{
139	mBlinkIcon = icon;
140	if ( mBlinkTimer->isActive() == false )
141	{
142	mIsBlinkIcon = true;
143	mIsBlinking = true;
144	mBlinkTimer->start( 1000, false );
145	}
146	else
147	{
148	mBlinkTimer->stop();
149	mIsBlinkIcon = true;
150	mIsBlinking = true;
151	mBlinkTimer->start( 1000, false );
152	}
153	}
154
155	void KopeteSystemTray::startBlink( const QMovie &movie )
156	{
157	//kdDebug( 14010 ) << k_funcinfo << "starting movie." << endl;
158	const_cast<QMovie &>( movie ).unpause();
159	setMovie( movie );
160	mIsBlinking = true;
161	}
162
163	void KopeteSystemTray::startBlink()
164	{
165	if ( mMovie.isNull() )
166	mMovie = KGlobal::iconLoader()->loadMovie( QString::fromLatin1( "newmessage" ), KIcon::Panel );
167
168	startBlink( mMovie );
169	}
170
171	void KopeteSystemTray::stopBlink()
172	{
173	if ( movie() )
174	kdDebug( 14010 ) << k_funcinfo << "stopping movie." << endl;
175	else if ( mBlinkTimer->isActive() )
176	mBlinkTimer->stop();
177
178	if ( !mMovie.isNull() )
179	mMovie.pause();
180
181	mIsBlinkIcon = false;
182	mIsBlinking = false;
183	//setPixmap( mKopeteIcon );
184	slotReevaluateAccountStates();
185	}
186
187	void KopeteSystemTray::slotBlink()
188	{
189	setPixmap( mIsBlinkIcon ? mKopeteIcon : mBlinkIcon );
190
191	mIsBlinkIcon = !mIsBlinkIcon;
192	}
193
194	void KopeteSystemTray::slotNewEvent( Kopete::MessageEvent *event )
195	{
196	mEventList.append( event );
197	connect(event, SIGNAL(done(Kopete::MessageEvent*)),
198	this, SLOT(slotEventDone(Kopete::MessageEvent*)));
199
200	if( event->message().manager() != 0 )
201	{
202	if( event->message().manager()->account() )
203	{
204	if( !event->message().manager()->account()->isAway() \|\|
205	KopetePrefs::prefs()->soundIfAway() )
206	{
207	addBalloon();
208	}
209	else
210	{
211	kdDebug(14000) << k_funcinfo << "Supressing balloon, account is away" << endl;
212	}
213	}
214	}
215	else
216	kdDebug(14000) << k_funcinfo << "NULL message().manager()!" << endl;
217
218	// tray animation
219	if ( KopetePrefs::prefs()->trayflashNotify() )
220	startBlink();
221	}
222
223	void KopeteSystemTray::slotEventDone(Kopete::MessageEvent *event)
224	{
225	bool current= event==mEventList.first();
226	mEventList.remove(event);
227
228	if(current && m_balloon)
229	{
230	m_balloon->deleteLater();
231	m_balloon=0l;
232	if(!mEventList.isEmpty())
233	addBalloon();
234	}
235
236	if(mEventList.isEmpty())
237	stopBlink();
238	}
239
240	void KopeteSystemTray::addBalloon()
241	{
242	/*kdDebug(14010) << k_funcinfo <<
243	m_balloon << ":" << KopetePrefs::prefs()->showTray() <<
244	":" << KopetePrefs::prefs()->balloonNotify()
245	<< ":" << !mEventList.isEmpty() << endl;*/
246
247	if( !m_balloon && KopetePrefs::prefs()->showTray() && KopetePrefs::prefs()->balloonNotify() && !mEventList.isEmpty() )
248	{
249	Kopete::Message msg = mEventList.first()->message();
250
251	if ( msg.from() )
252	{
253	QString msgText = squashMessage( msg );
254	kdDebug(14010) << k_funcinfo << "msg text=" << msgText << endl;
255
256	QString msgFrom;
257	if( msg.from()->metaContact() )
258	msgFrom = msg.from()->metaContact()->displayName();
259	else
260	msgFrom = msg.from()->contactId();
261
262	m_balloon = new KopeteBalloon(
263	i18n( "<qt><nobr><b>New Message from %1:</b></nobr><br><nobr>\"%2\"</nobr></qt>" )
264	.arg( msgFrom, msgText ), QString::null );
265	connect(m_balloon, SIGNAL(signalBalloonClicked()), mEventList.first() , SLOT(apply()));
266	connect(m_balloon, SIGNAL(signalButtonClicked()), mEventList.first() , SLOT(apply()));
267	connect(m_balloon, SIGNAL(signalIgnoreButtonClicked()), mEventList.first() , SLOT(ignore()));
268	m_balloon->setAnchor(mapToGlobal(pos()));
269	m_balloon->show();
270	KWin::setOnAllDesktops(m_balloon->winId(), true);
271	}
272	}
273	}
274
275	void KopeteSystemTray::slotConfigChanged()
276	{
277	// kdDebug(14010) << k_funcinfo << "called." << endl;
278	if ( KopetePrefs::prefs()->showTray() )
279	show();
280	else
281	hide(); // for users without kicker or a similar docking app
282	}
283
284	void KopeteSystemTray::slotReevaluateAccountStates()
285	{
286	// If there is a pending message, we don't need to refresh the system tray now.
287	// This function will even be called when the animation will stop.
288	if ( mIsBlinking )
289	return;
290
291
292	//kdDebug(14010) << k_funcinfo << endl;
293	bool bOnline = false;
294	bool bAway = false;
295	bool bOffline = false;
296	Kopete::Contact *c = 0;
297
298	for (QPtrListIterator<Kopete::Account> it(Kopete::AccountManager::self()->accounts()); it.current(); ++it)
299	{
300	c = it.current()->myself();
301	if (!c)
302	continue;
303
304	if (c->onlineStatus().status() == Kopete::OnlineStatus::Online)
305	{
306	bOnline = true; // at least one contact is online
307	}
308	else if (c->onlineStatus().status() == Kopete::OnlineStatus::Away
309	\|\| c->onlineStatus().status() == Kopete::OnlineStatus::Invisible)
310	{
311	bAway = true; // at least one contact is away or invisible
312	}
313	else // this account must be offline (or unknown, which I don't know how to handle)
314	{
315	bOffline = true;
316	}
317	}
318
319	if (!bOnline && !bAway && !bOffline) // special case, no accounts defined (yet)
320	bOffline = true;
321
322	if (bAway)
323	{
324	if (!bOnline && !bOffline) // none online and none offline -> all away
325	setPixmap(loadIcon("kopete_all_away"));
326	else
327	setPixmap(loadIcon("kopete_some_away"));
328	}
329	else if(bOnline)
330	{
331	/*if(bOffline) // at least one offline and at least one online -> some accounts online
332	setPixmap(loadIcon("kopete_some_online"));
333	else*/ // none offline and none away -> all online
334	setPixmap(mKopeteIcon);
335	}
336	else // none away and none online -> all offline
337	{
338	//kdDebug(14010) << k_funcinfo << "All Accounts offline!" << endl;
339	setPixmap(loadIcon("kopete_offline"));
340	}
341	}
342
343
344	QString KopeteSystemTray::squashMessage( const Kopete::Message& msg )
345	{
346	QString msgText = msg.parsedBody();
347
348	QRegExp rx( "(<a.*>((http://)?(.+))</a>)" );
349	rx.setMinimal( true );
350	if ( rx.search( msgText ) == -1 )
351	{
352	// no URLs in text, just pick the first 30 chars of
353	// the parsed text if necessary. We used parsed text
354	// so that things like "<knuff>" show correctly
355	// Escape it after snipping it to not snip entities
356	msgText =msg.plainBody() ;
357	if( msgText.length() > 30 )
358	msgText = msgText.left( 30 ) + QString::fromLatin1( " ..." );
359	msgText=Kopete::Message::escape(msgText);
360	}
361	else
362	{
363	QString plainText = msg.plainBody();
364	if ( plainText.length() > 30 )
365	{
366	QString fullUrl = rx.cap( 2 );
367	QString shorterUrl;
368	if ( fullUrl.length() > 30 )
369	{
370	QString urlWithoutProtocol = rx.cap( 4 );
371	shorterUrl = urlWithoutProtocol.left( 27 )
372	+ QString::fromLatin1( "... " );
373	}
374	else
375	{
376	shorterUrl = fullUrl.left( 27 )
377	+ QString::fromLatin1( "... " );
378	}
379	// remove message text
380	msgText = QString::fromLatin1( "... " ) +
381	rx.cap( 1 ) +
382	QString::fromLatin1( " ..." );
383	// find last occurrence of URL (the one inside the <a> tag)
384	int revUrlOffset = msgText.findRev( fullUrl );
385	msgText.replace( revUrlOffset,
386	fullUrl.length(), shorterUrl );
387	}
388	}
389	return msgText;
390	}
391
392	#include "systemtray.moc"
393	// vim: set noet ts=4 sts=4 sw=4: