QT4 new stuff and ftp/http(wip) new classes (lack of docs :\)

git-svn-id: https://svn.kvirc.de/svn/trunk/kvirc@2441 17fca916-40b9-46aa-a4ea-0a15b648b75c

29 files changed, 1356 insertions, 210 deletions

diff --git a/src/modules/objects/CMakeLists.txt b/src/modules/objects/CMakeLists.txt
index e58351cf0..9c713ba83 100644
--- a/src/modules/objects/CMakeLists.txt
+++ b/src/modules/objects/CMakeLists.txt
@@ -12,6 +12,8 @@ SET(kviobjects_MOC_HDRS
 	class_checkbox.h
 	class_combobox.h
 	class_dockwindow.h
+	class_ftp.h
+	class_http.h
 	class_lineedit.h
 	class_listbox.h
 	class_listview.h
@@ -45,7 +47,9 @@ SET(kviobjects_SRCS
 	class_dialog.cpp
 	class_dockwindow.cpp
 	class_file.cpp
+	class_ftp.cpp
 	class_groupbox.cpp
+	class_http.cpp
 	class_label.cpp
 	class_layout.cpp
 	class_lcd.cpp
diff --git a/src/modules/objects/class_file.cpp b/src/modules/objects/class_file.cpp
index 59196826d..726019b55 100644
--- a/src/modules/objects/class_file.cpp
+++ b/src/modules/objects/class_file.cpp
@@ -170,6 +170,10 @@ KVSO_BEGIN_REGISTERCLASS(KviKvsObject_file,"file","object")
 	KVSO_REGISTER_HANDLER(KviKvsObject_file,"getch", functiongetch)
 	KVSO_REGISTER_HANDLER(KviKvsObject_file,"ungetch", functionunGetch)
 	KVSO_REGISTER_HANDLER(KviKvsObject_file,"readBlock", functionreadBlock)
+
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"readHexBlock", functionreadHexBlock)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"writeHexBlock", functionwriteHexBlock)
+	
 	KVSO_REGISTER_HANDLER(KviKvsObject_file,"writeBlock", functionwriteBlock)
 	KVSO_REGISTER_HANDLER(KviKvsObject_file,"readLine", functionreadLine)
 	KVSO_REGISTER_HANDLER(KviKvsObject_file,"writeLine", functionwriteLine)
@@ -287,7 +291,7 @@ bool KviKvsObject_file::functionseek(KviKvsObjectFunctionCall *c)
 	KVSO_PARAMETERS_END(c)
 	if (!m_pFile) return true;
 	if(!m_pFile->isOpen())
-		c->warning(__tr("File is not open !"));
+		c->warning(__tr2qs("File is not open !"));
 	else m_pFile->seek(uIndex);
 	return true;
 }
@@ -312,11 +316,11 @@ bool KviKvsObject_file::functiongetch(KviKvsObjectFunctionCall *c)
 {
 	if (!m_pFile) return true;
 	if(!m_pFile->isOpen())
-		c->warning(__tr("File is not open !"));
+		c->warning(__tr2qs("File is not open !"));
 	else
 	{
 		char ch;
-		if (!m_pFile->getChar(&ch)) c->warning(__tr("Read error occured !"));	// c->error ?
+		if (!m_pFile->getChar(&ch)) c->warning(__tr2qs("Read error occured !"));	// c->error ?
 		QString szChar = QChar(ch);
 		c->returnValue()->setString(szChar);
 	}
@@ -330,7 +334,7 @@ bool KviKvsObject_file::functionunGetch(KviKvsObjectFunctionCall *c)
 	KVSO_PARAMETERS_END(c)
 	if (!m_pFile) return true;
 	if(!m_pFile->isOpen())
-		c->warning(__tr("File is not open !"));
+		c->warning(__tr2qs("File is not open !"));
 	else
 	{
 		if (szChar.length()>1) c->warning(__tr2qs("Argument to long, using only first char"));
@@ -346,10 +350,12 @@ bool KviKvsObject_file::functionreadBlock(KviKvsObjectFunctionCall *c)
 		KVSO_PARAMETER("lenght",KVS_PT_UNSIGNEDINTEGER,0,uLen)
 	KVSO_PARAMETERS_END(c)
 	if (!m_pFile) return true;
-	if(!m_pFile->isOpen())
-		c->warning(__tr("File is not open !"));
+	if(!m_pFile->isOpen()){
+		c->warning(__tr2qs("File is not open !"));
+	}
 	else
 	{
+
 		char * buff = new char[uLen + 1];
 		m_pFile->flush(); // advice from QFile man page (to avoid trash)
 		int rlen = m_pFile->read(buff, uLen);
@@ -370,7 +376,7 @@ bool KviKvsObject_file::functionwriteBlock(KviKvsObjectFunctionCall *c)
 	KVSO_PARAMETERS_END(c)
 	if (!m_pFile) return true;
 	if(!m_pFile->isOpen())
-		c->warning(__tr("File is not open !"));
+		c->warning(__tr2qs("File is not open !"));
 	const char *block=szBlock.toUtf8().data();
 	int rlen = m_pFile->write(block, uLen);
 	c->returnValue()->setInteger(rlen);
@@ -381,7 +387,7 @@ bool KviKvsObject_file::functionreadLine(KviKvsObjectFunctionCall *c)
 {
 	if (!m_pFile) return true;
 	if(!m_pFile->isOpen())
-		c->warning(__tr("File is not open !"));
+		c->warning(__tr2qs("File is not open !"));
 	else
 	{
 		QString buffer;
@@ -398,7 +404,7 @@ bool KviKvsObject_file::functionwriteLine(KviKvsObjectFunctionCall *c)
 	KVSO_PARAMETERS_END(c)
 	if (!m_pFile) return true;
 	if(!m_pFile->isOpen())
-		c->warning(__tr("File is not open !"));
+		c->warning(__tr2qs("File is not open !"));
 	else
 	{
 		QTextStream ts(m_pFile);
@@ -406,52 +412,71 @@ bool KviKvsObject_file::functionwriteLine(KviKvsObjectFunctionCall *c)
 	}
 	return true;
 }
-// fixme
-/*
-
-bool KviScriptFileObject::functionHexWrite(KviCommand * c, KviParameterList * p,
-	KviStr & b)
+bool KviKvsObject_file::functionreadHexBlock(KviKvsObjectFunctionCall *c)
 {
-	ENTER_STACK_FRAME(c, "file::hexWrite");
-	if(!p->count())
-		return c->error(KviError_notEnoughParameters);
-
-	char * val = 0;
-	int len = p->first()->hexToBuffer(&val,false);
-
-	if(len < 1)
+	kvs_uint_t uLen;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("lenght",KVS_PT_UNSIGNEDINTEGER,0,uLen)
+	KVSO_PARAMETERS_END(c)
+	if (!m_pFile) return true;
+	if(!m_pFile->isOpen())
+		c->warning(__tr2qs("File is not open !"));
+	else
 	{
-		c->warning(__tr("Nothing to write"));
-		return c->leaveStackFrame();
+		if (uLen>m_pFile->size()) uLen=m_pFile->size();
+		char * buff = new char[(uLen*2) + 1];
+		char * cc=buff;
+		m_pFile->flush(); // advice from QFile man page (to avoid trash)
+		int rlen = m_pFile->read(buff, uLen);
+		QString szHex;
+		unsigned char byte,msb,lsb=0;
+		int index=0;
+		for (int i=0;i<uLen;i++)
+		{
+			m_pFile->getChar((char*)&byte);
+			msb=(byte/16);
+			lsb=(byte%16);
+			msb>9?msb+='7':msb+='0';
+			lsb>9?lsb+='7':lsb+='0';
+			buff[index]=msb;
+			index++;
+			buff[index]=lsb;
+			index++;
+		}
+		buff[index]='\0';
+		c->returnValue()->setString(buff);
 	}
-
-	if(!m_pFile->isOpen())
-		c->warning(__tr("File is not open !"));
-
-	if(m_pFile->putch(*val) < 0)
-		c->warning(__tr("Write error occured !"));	// c->error ?
-
-	KviStr::freeBuffer(val);
-
-	return c->leaveStackFrame();
+	return true;
 }
-
-bool KviScriptFileObject::functionHexRead(KviCommand * c, KviParameterList * p,
-	KviStr & b)
+bool KviKvsObject_file::functionwriteHexBlock(KviKvsObjectFunctionCall *c)
 {
- 	if(!m_pFile->isOpen())
- 		c->warning(__tr("File is not open !"));
-
-	char ch = m_pFile->getch();
-
-	KviStr tmp;
- 	tmp.bufferToHex(&ch, 1);
- 	b.append(tmp);
-
- 	return true;
+	QString szBlock;
+	kvs_uint_t uLen;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("text_block",KVS_PT_STRING,0,szBlock)
+		KVSO_PARAMETER("lenght",KVS_PT_UNSIGNEDINTEGER,KVS_PF_OPTIONAL,uLen)
+	KVSO_PARAMETERS_END(c)
+	if (!m_pFile) return true;
+	if(!m_pFile->isOpen()){
+		c->warning(__tr2qs("File is not open !"));
+		return true;
+	}
+	if (uLen>(szBlock.length()/2)|| !uLen) uLen=szBlock.length();
+	else uLen*=2;
+	unsigned char byte,lsb,msb;
+	for(int i=0;i<uLen;i+=2)
+	{
+		msb=szBlock.at(i).toAscii();
+		msb>='A'?msb-='7':msb-='0';
+		lsb=szBlock.at(i+1).toAscii();
+		lsb>='A'?lsb-='7':lsb-='0';
+		byte=(msb*16)+lsb;
+		m_pFile->putChar(byte);
+	}
+	c->returnValue()->setInteger(uLen/2);
+	return true;
 }
 
-*/
 
 #ifndef COMPILE_USE_STANDALONE_MOC_SOURCES
 #include "m_class_file.moc"
diff --git a/src/modules/objects/class_file.h b/src/modules/objects/class_file.h
index 4d318abcb..0c7677c3f 100644
--- a/src/modules/objects/class_file.h
+++ b/src/modules/objects/class_file.h
@@ -106,6 +106,9 @@ protected:
 /*	bool functionHexWrite(KviKvsObjectFunctionCall *c);
 	bool functionHexRead(KviKvsObjectFunctionCall *c);
 */
+	bool functionreadHexBlock(KviKvsObjectFunctionCall *c);
+	
+bool functionwriteHexBlock(KviKvsObjectFunctionCall *c);
 protected:
 	QFile * m_pFile;
 };
diff --git a/src/modules/objects/class_ftp.cpp b/src/modules/objects/class_ftp.cpp
new file mode 100644
index 000000000..d42178cef
--- /dev/null
+++ b/src/modules/objects/class_ftp.cpp
@@ -0,0 +1,242 @@
+//
+//   File : class_ftp.cpp
+//   Creation date : Mon Sep 1 08:13:45 2008 GMT by Carbone Alesssandro
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 2001 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. ,59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+
+#include "kvi_debug.h"
+#include "kvi_error.h"
+#include "class_ftp.h"
+#include <QFtp>
+
+
+
+/*
+	@doc: ftp
+	@keyterms:
+		ftp object class
+	@title:
+		ftp class
+	@type:
+		class
+	@short:
+		An implementation of the client side of FTP protocol.
+	@inherits:
+		[class]object[/class]
+	@description:
+		This class provides a standard FTP functionality.[br]
+	@functions:
+		!fn: $dataAvailableEvent(<data_length>)
+		This function is called when some data is available to be read: the <data_length> parameter specifies
+		the length of the available data in bytes.[br]
+		You can use one of the $read* functions to obtain the data.
+
+		!fn: $connect(<host:string>,<remote_port:integer>)
+		Connects to the FTP server host using port port.The command is scheduled, and its execution is performed asynchronously. 
+		The function returns a unique identifier which is passed by commandStarted() and commandFinished().[br]
+		!fn: $abort()
+		!fn: $login
+		!fn: $get
+		!fn: $cd
+		!fn: $list
+		!fn: 
+		*/
+
+KVSO_BEGIN_REGISTERCLASS(KviKvsObject_ftp,"ftp","object")
+	KVSO_REGISTER_HANDLER(KviKvsObject_ftp,"connect",functionConnect)
+	KVSO_REGISTER_HANDLER(KviKvsObject_ftp,"abort",functionAbort)
+	KVSO_REGISTER_HANDLER(KviKvsObject_ftp,"login",functionLogin)
+	KVSO_REGISTER_HANDLER(KviKvsObject_ftp,"get",functionGet)
+	KVSO_REGISTER_HANDLER(KviKvsObject_ftp,"cd",functionCd)
+	KVSO_REGISTER_HANDLER(KviKvsObject_ftp,"list",functionList)
+	KVSO_REGISTER_HANDLER(KviKvsObject_ftp,"commandFinishedEvent",function_commandFinishedEvent)
+	KVSO_REGISTER_HANDLER(KviKvsObject_ftp,"listInfoEvent",function_listInfoEvent)
+	KVSO_REGISTER_HANDLER(KviKvsObject_ftp,"dataTransferProgressEvent",function_dataTransferProgressEvent)
+KVSO_END_REGISTERCLASS(KviKvsObject_ftp)
+
+
+KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_ftp,KviKvsObject)
+	m_pFtp = new QFtp();
+	m_pFile=0;
+	connect(m_pFtp,SIGNAL(commandFinished(int,bool)),this,SLOT(slotCommandFinished(int,bool)));
+	connect(m_pFtp,SIGNAL(commandStarted(int)),this,SLOT(slotCommandStarted(int)));
+	connect(m_pFtp,SIGNAL(dataTransferProgress(qint64,qint64)),this,SLOT(slotDataTransferProgress(qint64,qint64)));
+	connect(m_pFtp,SIGNAL(done(bool)),this,SLOT(slotDone(bool)));
+	connect(m_pFtp,SIGNAL(listInfo(const QUrlInfo)),this,SLOT(slotListInfo(const QUrlInfo)));
+	connect(m_pFtp,SIGNAL(rawCommandReply(int,QString)),this,SLOT(slotRawCommandReplay(int,QString)));
+	connect(m_pFtp,SIGNAL(readyRead()),this,SLOT(slotReadyRead()));
+	connect(m_pFtp,SIGNAL(stateChanged(int)),this,SLOT(slotStateChanged(int)));
+KVSO_END_CONSTRUCTOR(KviKvsObject_ftp)
+
+KVSO_BEGIN_DESTRUCTOR(KviKvsObject_ftp)
+	if (m_pFile) delete m_pFile;
+KVSO_END_DESTRUCTOR(KviKvsObject_ftp)
+//----------------------
+
+
+
+
+
+bool  KviKvsObject_ftp::functionConnect(KviKvsObjectFunctionCall *c)
+{
+	QString szHost;
+	kvs_uint_t uRemotePort;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("host",KVS_PT_STRING,0,szHost)
+		KVSO_PARAMETER("remote_port",KVS_PT_UNSIGNEDINTEGER,KVS_PF_OPTIONAL,uRemotePort)
+	KVSO_PARAMETERS_END(c)
+	if (!uRemotePort) uRemotePort=21;
+	kvs_uint_t id=0;
+	if (m_pFtp) id=m_pFtp->connectToHost(szHost, uRemotePort);
+	c->returnValue()->setInteger(id);
+	return true;
+}
+bool  KviKvsObject_ftp::functionLogin(KviKvsObjectFunctionCall *c)
+{
+	QString szUser,szPass;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("user",KVS_PT_STRING,0,szUser)
+		KVSO_PARAMETER("password",KVS_PT_STRING,0,szPass)
+	KVSO_PARAMETERS_END(c)
+	int id=0;
+	if (m_pFtp) id=m_pFtp->login(szUser, szPass);
+	c->returnValue()->setInteger(id);
+	return true;
+}
+bool  KviKvsObject_ftp::functionGet(KviKvsObjectFunctionCall *c)
+{
+	QString szFile,szDest;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("remote_filename",KVS_PT_STRING,0,szFile)
+		KVSO_PARAMETER("local_filename",KVS_PT_STRING,0,szDest)
+	KVSO_PARAMETERS_END(c)
+	m_pFile=new QFile(szDest);
+	m_pFile->open(QIODevice::WriteOnly);
+	int id=0;
+	if (m_pFtp) id=m_pFtp->get(szFile,m_pFile);
+	c->returnValue()->setInteger(id);
+	return true;
+}
+bool  KviKvsObject_ftp::functionCd(KviKvsObjectFunctionCall *c)
+{
+	QString szPath;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("remote_filename",KVS_PT_STRING,0,szPath)
+	KVSO_PARAMETERS_END(c)
+	int id=0;
+	if (m_pFtp) id=m_pFtp->cd(szPath);
+	c->returnValue()->setInteger(id);
+	return true;
+}
+bool  KviKvsObject_ftp::functionList(KviKvsObjectFunctionCall *c)
+{
+	QString szPath;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("remote_dir",KVS_PT_STRING,0,szPath)
+	KVSO_PARAMETERS_END(c)
+	int id=0;
+	if (m_pFtp) id=m_pFtp->list(szPath);
+	c->returnValue()->setInteger(id);
+	return true;
+}
+bool  KviKvsObject_ftp::functionAbort(KviKvsObjectFunctionCall *c)
+{
+	if (m_pFtp) m_pFtp->abort();
+	return true;
+}
+//signals & slots 
+bool KviKvsObject_ftp::function_commandFinishedEvent(KviKvsObjectFunctionCall *c)
+{
+	emitSignal("commandFinished",c,c->params());
+	return true;
+}
+
+void KviKvsObject_ftp::slotCommandFinished ( int id, bool error )

+{

+	QString status=""; 

+	if (m_pFtp->currentCommand()==QFtp::Get){

+		status="Finished to load"; 

+		m_pFile->close();

+		delete m_pFile;

+	}

+	else if (m_pFtp->currentCommand()==QFtp:: ConnectToHost) status="connected"; 

+	else if (m_pFtp->currentCommand()==QFtp:: Login) status="logged"; 

+	else if (m_pFtp->currentCommand()==QFtp:: Cd) status="entered"; 

+	else if (m_pFtp->currentCommand()==QFtp:: List) status="listCompleted"; 

+	callFunction(this,"commandFinishedEvent",0,new KviKvsVariantList(new KviKvsVariant((kvs_int_t) id),
+		new KviKvsVariant(status),new KviKvsVariant(error)));

+}

+

+void KviKvsObject_ftp::slotCommandStarted ( int id )

+{

+}

+

+void KviKvsObject_ftp::slotDataTransferProgress ( qint64 done, qint64 total )

+{

+	callFunction(this,"dataTransferProgressEvent",0,new KviKvsVariantList(
+		new KviKvsVariant(done),new KviKvsVariant(total)));

+}

+bool KviKvsObject_ftp::function_dataTransferProgressEvent(KviKvsObjectFunctionCall *c)
+{
+	emitSignal("dataTransferProgress",c,c->params());
+	return true;
+}

+void KviKvsObject_ftp::slotDone ( bool error )

+{

+}

+

+void KviKvsObject_ftp::slotListInfo ( const QUrlInfo & i )

+{

+	callFunction(this,"listInfoEvent",0,new KviKvsVariantList(
+		new KviKvsVariant(i.name())));

+	

+}

+bool KviKvsObject_ftp::function_listInfoEvent(KviKvsObjectFunctionCall *c)
+{
+	emitSignal("listInfo",c,c->params());
+	return true;
+}

+void KviKvsObject_ftp::slotRawCommandReply ( int replyCode, const QString & detail )

+{

+}

+

+void KviKvsObject_ftp::slotReadyRead ()

+{

+}

+

+void KviKvsObject_ftp::slotStateChanged ( int state)

+{

+	QString szState="";

+	if (state==QFtp::Unconnected) szState="Unconnected";

+	else if (state==QFtp::HostLookup) szState="HostLookup";

+	else if (state==QFtp::Connecting) szState="Connecting";

+	else if (state==QFtp::Connected) szState="Connected";

+	else if (state==QFtp::LoggedIn) szState="LoggedIn";

+	else if (state==QFtp::Closing) szState="Closing";

+	callFunction(this,"stateChangedEvent",0,new KviKvsVariantList(
+		new KviKvsVariant(szState)));

+}

+bool KviKvsObject_ftp::function_stateChangedEvent(KviKvsObjectFunctionCall *c)
+{
+	emitSignal("stateChanged",c,c->params());
+	return true;
+}

+#ifndef COMPILE_USE_STANDALONE_MOC_SOURCES
+#include "m_class_ftp.moc"
+#endif //!COMPILE_USE_STANDALONE_MOC_SOURCES
diff --git a/src/modules/objects/class_ftp.h b/src/modules/objects/class_ftp.h
new file mode 100644
index 000000000..465c18987
--- /dev/null
+++ b/src/modules/objects/class_ftp.h
@@ -0,0 +1,63 @@
+#ifndef _CLASS_FTP_H_
+#define _CLASS_FTP_H_
+//
+//   File : class_ftp.h
+//   Creation date : Mon Sep 1 08:13:45 2008 GMT by Carbone Alesssandro
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 2001 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. ,59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+
+
+
+
+//===============================================================
+#include "object_macros.h"
+#include <QFtp>
+#include <QFile>
+
+class KviKvsObject_ftp : public KviKvsObject
+{
+	Q_OBJECT
+public:
+	KVSO_DECLARE_OBJECT(KviKvsObject_ftp)
+protected:
+	QFtp *m_pFtp;
+	QFile *m_pFile;
+protected:
+	bool functionConnect(KviKvsObjectFunctionCall *c);
+	bool functionGet(KviKvsObjectFunctionCall *c);
+	bool functionLogin(KviKvsObjectFunctionCall *c);
+	bool functionCd(KviKvsObjectFunctionCall *c);
+	bool functionList(KviKvsObjectFunctionCall *c);
+	bool function_dataTransferProgressEvent(KviKvsObjectFunctionCall *c);
+	bool function_listInfoEvent(KviKvsObjectFunctionCall *c);
+	bool function_commandFinishedEvent(KviKvsObjectFunctionCall *c);
+	bool function_stateChangedEvent(KviKvsObjectFunctionCall *c);
+	bool functionAbort(KviKvsObjectFunctionCall *c);
+
+protected slots:
+	void slotCommandFinished ( int id, bool error );

+	void slotCommandStarted ( int id );

+	void slotDataTransferProgress ( qint64 done, qint64 total );

+	void slotDone ( bool error );

+	void slotListInfo ( const QUrlInfo & i );

+	void slotRawCommandReply ( int replyCode, const QString & detail );

+	void slotReadyRead ();

+	void slotStateChanged ( int state);
+};
+#endif //_CLASS_FTP_H_
diff --git a/src/modules/objects/class_groupbox.cpp b/src/modules/objects/class_groupbox.cpp
index 4ed71cab3..59960b2d0 100644
--- a/src/modules/objects/class_groupbox.cpp
+++ b/src/modules/objects/class_groupbox.cpp
@@ -178,6 +178,7 @@ KVSO_END_CONSTRUCTOR(KviKvsObject_groupbox)
 bool KviKvsObject_groupbox::init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams)
 {
 	KviTalGroupBox *groupbox=new KviTalGroupBox(getName(),parentScriptWidget());
+	groupbox->setOrientation(Qt::Horizontal);
 	groupbox->setObjectName(getName());
 	setObject(groupbox,true);
 	return true;
diff --git a/src/modules/objects/class_hbox.cpp b/src/modules/objects/class_hbox.cpp
index 77c7c6d5f..da9b31cdd 100644
--- a/src/modules/objects/class_hbox.cpp
+++ b/src/modules/objects/class_hbox.cpp
@@ -25,6 +25,32 @@
 #include "class_hbox.h"
 #include "kvi_tal_hbox.h"
 
+const char * const align_tbl[] = {
+			"Left", 
+			"Right",
+			"HCenter",
+			"VCenter",
+			"Center",
+			"Top",
+			"Bottom",
+			"WordBreak"
+			   };
+
+
+
+const int align_cod[] = {
+		Qt::AlignLeft,
+		Qt::AlignRight,
+	    Qt::AlignHCenter,
+	    Qt::AlignVCenter,
+	    Qt::AlignCenter,
+	 	Qt::AlignTop,
+	    Qt::AlignBottom,
+	    Qt::AlignJustify,
+	};
+
+#define align_num	(sizeof(align_tbl) / sizeof(align_tbl[0]))
+
 /*
 	@doc: hbox
 	@keyterms:
@@ -46,6 +72,11 @@
 		Sets the dimension of the layout margin : the distance from the border to the outermost child widget edges.
 		!fn: $setStretchFactor(<widget:hobject>,<stretch:uint>)
 		Sets the stretch factor of widget to stretch.
+		!fn: $addStretch(<stretch:integer>)
+		Adds a stretchable space with zero minimum size and stretch factor stretch to the end of this box layout.
+		!fn: $setAlignment(<flag1:string>, <flag2:string>, ...)
+		Sets the alignment for widget w to  flags, given as parameters. 
+		Valid flags are:Right,Left,Top,Bottom,HCenter,VCenter,Center  
 */
 
 
@@ -53,6 +84,8 @@ KVSO_BEGIN_REGISTERCLASS(KviKvsObject_hbox,"hbox","widget")
 	KVSO_REGISTER_HANDLER(KviKvsObject_hbox,"setMargin", functionsetMargin)
 	KVSO_REGISTER_HANDLER(KviKvsObject_hbox,"setSpacing", functionsetSpacing)
 	KVSO_REGISTER_HANDLER(KviKvsObject_hbox,"setStretchFactor", functionsetStretchFactor )
+	KVSO_REGISTER_HANDLER(KviKvsObject_hbox,"addStretch", functionaddStretch )
+	KVSO_REGISTER_HANDLER(KviKvsObject_hbox,"setAlignment", functionsetAlignment )
 KVSO_END_REGISTERCLASS(KviKvsObject_hbox)
 
 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_hbox,KviKvsObject_widget)
@@ -125,3 +158,66 @@ bool KviKvsObject_hbox::functionsetStretchFactor(KviKvsObjectFunctionCall *c)
 	((KviTalHBox *)widget())->setStretchFactor(((QWidget *)(pObject->object())),uStretch);
 	return true;
 }
+bool KviKvsObject_hbox::functionaddStretch(KviKvsObjectFunctionCall *c)
+{
+	kvs_int_t iStretch;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("stretch",KVS_PT_INT,0,iStretch)
+	KVSO_PARAMETERS_END(c)
+	if (widget()) ((KviTalHBox *)widget())->addStretch(iStretch);
+	return true;
+}
+bool KviKvsObject_hbox::functionsetAlignment(KviKvsObjectFunctionCall *c)
+{
+	QStringList alignment;
+	KviKvsObject * pObject;
+	kvs_hobject_t hObject;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("widget",KVS_PT_HOBJECT,0,hObject)
+		KVSO_PARAMETER("alignment",KVS_PT_STRINGLIST,KVS_PF_OPTIONAL,alignment)
+	KVSO_PARAMETERS_END(c)
+	pObject=KviKvsKernel::instance()->objectController()->lookupObject(hObject);
+	if(!widget())return true;
+	if (!pObject)
+	{
+		c->warning(__tr2qs("Widget parameter is not an object"));
+		return true;
+	}
+	if (!pObject->object())
+	{
+		c->warning(__tr2qs("Widget parameter is not a valid object"));
+		return true;
+	}
+	if(!pObject->object()->isWidgetType())
+	{
+		c->warning(__tr2qs("Can't add a non-widget object"));
+		return true;
+	}
+	if(((KviKvsObject_widget *)pObject)->widget()->parentWidget() != widget())
+	{
+		c->warning(__tr2qs("The widget must be a child of this hbox"));
+		return true;
+	}
+
+	int align,sum=0;
+	for ( QStringList::Iterator it = alignment.begin(); it != alignment.end(); ++it )
+		{
+		
+			align = 0;
+			for(unsigned int j = 0; j < align_num; j++)
+			{
+				if(KviQString::equalCI((*it), align_tbl[j]))
+				{
+					align=align_cod[j];
+					break;
+				}
+			}
+			if(align)
+				sum = sum | align;
+			else
+				c->warning(__tr2qs("Unknown alignment: '%Q'"),&(*it));
+			
+		}
+	if (widget()) ((KviTalHBox *)widget())->setAlignment(((QWidget *)(pObject->object())),(Qt::Alignment)sum);
+	return true;
+}
\ No newline at end of file
diff --git a/src/modules/objects/class_hbox.h b/src/modules/objects/class_hbox.h
index 531eed2f0..35fbcb371 100644
--- a/src/modules/objects/class_hbox.h
+++ b/src/modules/objects/class_hbox.h
@@ -37,6 +37,8 @@ protected:
 	bool functionsetMargin(KviKvsObjectFunctionCall *c);
 	bool functionsetSpacing(KviKvsObjectFunctionCall *c);
 	bool functionsetStretchFactor(KviKvsObjectFunctionCall *c);
+	bool functionaddStretch(KviKvsObjectFunctionCall *c);
+	bool functionsetAlignment(KviKvsObjectFunctionCall *c);
 
 
 };
diff --git a/src/modules/objects/class_http.cpp b/src/modules/objects/class_http.cpp
new file mode 100644
index 000000000..88dbf8457
--- /dev/null
+++ b/src/modules/objects/class_http.cpp
@@ -0,0 +1,443 @@
+//
+//   File : class_http.cpp
+//   Creation date : Fry Sep 5 18:13:45 2008 GMT by Carbone Alesssandro
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 2001 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. ,59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+
+#include "kvi_debug.h"
+#include "kvi_error.h"
+#include "kvi_locale.h"
+#include "class_http.h"
+#include <QHttp>
+#include <QUrl>
+#ifndef QT_NO_OPENSSL

+
+#include <QSslError>
+
+const char * const ssl_errors_tbl[] = {
+		"NoError",	

+		"UnableToGetIssuerCertificate",

+		"UnableToDecryptCertificateSignature",

+		"UnableToDecodeIssuerPublicKey",

+		"CertificateSignatureFailed",

+		"CertificateNotYetValid",

+		"CertificateExpired",

+		"InvalidNotBeforeField",

+		"InvalidNotAfterField",

+		"SelfSignedCertificate",

+		"SelfSignedCertificateInChain",	

+		"UnableToGetLocalIssuerCertificate",	

+		"UnableToVerifyFirstCertificate",

+		"CertificateRevoked",

+		"InvalidCaCertificate",	

+		"PathLengthExceeded",

+		"InvalidPurpose",	

+		"CertificateUntrusted",	

+		"CertificateRejected",	

+		"SubjectIssuerMismatch",	

+		"AuthorityIssuerSerialNumberMismatch",

+		"NoPeerCertificate",	

+		"HostNameMismatch",	

+		"UnspecifiedError",

+		"NoSslSupport"
+	};
+
+#endif
+/*
+	@doc: http
+	@keyterms:
+		http object class
+	@title:
+		http class
+	@type:
+		class
+	@short:
+		An implementation of the client side of HTTP protocol.
+	@inherits:
+		[class]object[/class]
+	@description:
+		This class provides a standard HTTP functionality.[br]
+	@functions:
+		!fn: $dataAvailableEvent(<data_length>)
+		This function is called when some data is available to be read: the <data_length> parameter specifies
+		the length of the available data in bytes.[br]
+		You can use one of the $read* functions to obtain the data.
+
+		!fn: $read(<length>)
+		Reads at most <length> bytes of data from the socket. If <length> is anything "outside" the
+		available data range (<length> < 0 or <length> > available_data_length), this function
+		returns all the available data.[br]
+		Please note that this function can't deal withi binary data: NULL characters are transformed to
+		ASCII characters 255.
+
+		*/
+
+KVSO_BEGIN_REGISTERCLASS(KviKvsObject_http,"http","object")
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"get",functionGet)
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"post",functionPost)
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"abort",functionAbort)
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"setHost",functionSetHost)
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"setProxy",functionSetProxy)
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"setUser",functionSetUser)
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"readAll",functionReadAll)
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"errorString",functionErrorString)
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"doneEvent",functionDoneEvent)
+	#ifndef QT_NO_OPENSSL

+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"ignoreSSlErrors",functionIgnoreSslErrors)
+	#endif
+	// events
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"requestFinishedEvent",functionRequestFinishedEvent)
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"requestStartedEvent",functionRequestStartedEvent)
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"responseHeaderReceivedEvent",functionResponseHeaderReceivedEvent)
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"dataReadProgressEvent",functionDataReadProgressEvent)
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"dataSendProgressEvent",functionDataSendProgressEvent)
+
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"stateChangedEvent",functionStateChangedEvent)
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"readyReadEvent",functionReadyReadEvent)
+	 #ifndef QT_NO_OPENSSL

+
+	KVSO_REGISTER_HANDLER(KviKvsObject_http,"sslErrorsEvent",functionSslErrorsEvent)
+#endif
+KVSO_END_REGISTERCLASS(KviKvsObject_http)
+
+
+KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_http,KviKvsObject)
+	m_pHttp = new QHttp();
+	m_bAbort=false;
+	connect(m_pHttp,SIGNAL(requestFinished(int,bool)),this,SLOT(slotRequestFinished(int,bool)));
+	connect(m_pHttp,SIGNAL(done(bool)),this,SLOT(slotDone(bool)));
+	
+	connect(m_pHttp,SIGNAL(requestStarted(int)),this,SLOT(slotRequestStarted(int)));
+	connect(m_pHttp,SIGNAL(dataSendProgress(int,int)),this,SLOT(slotDataSendProgress(int,int)));
+	connect(m_pHttp,SIGNAL(dataReadProgress(int,int)),this,SLOT(slotDataReadProgress(int,int)));
+	connect(m_pHttp,SIGNAL(responseHeaderReceived ( const QHttpResponseHeader & )),this,SLOT(slotResponseHeaderReceived(const QHttpResponseHeader &)));
+	connect(m_pHttp,SIGNAL(readyRead ( const QHttpResponseHeader & )),this,SLOT(slotReadyRead(const QHttpResponseHeader &)));
+	#ifndef QT_NO_OPENSSL
+	connect(m_pHttp,SIGNAL(sslErrors ( const QList<QSslError> & )),this,SLOT(slotSslErrors(const QList<QSslError> & )));
+	#endif
+	connect(m_pHttp,SIGNAL(stateChanged(int)),this,SLOT(slotStateChanged(int)));
+
+KVSO_END_CONSTRUCTOR(KviKvsObject_http)
+
+KVSO_BEGIN_DESTRUCTOR(KviKvsObject_http)
+	QHashIterator<int,QFile *> t(getDict);

+/*

+

+	while (t.hasNext()) 

+	{

+		t.next();

+		int key=t.key();

+		QFile *pFile=getDict.value(key);

+		pFile->close();

+		delete pFile;

+	}

+*/

+	delete m_pHttp;

+	getDict.clear();
+
+KVSO_END_DESTRUCTOR(KviKvsObject_http)
+//----------------------
+
+
+bool  KviKvsObject_http::functionSetHost(KviKvsObjectFunctionCall *c)
+{
+	QString szHost;
+	QString szConnectionType;
+	kvs_uint_t uRemotePort;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("host",KVS_PT_STRING,0,szHost)
+		KVSO_PARAMETER("remote_port",KVS_PT_UNSIGNEDINTEGER,KVS_PF_OPTIONAL,uRemotePort)
+	KVSO_PARAMETERS_END(c)
+	QUrl url(szHost);
+
+	if (!url.isValid())
+	{
+		c->warning(__tr2qs("Host '%Q' is not a valid url"),&szHost);
+		return true;
+	}
+	if (!szHost.isEmpty() && url.host().isEmpty()) url.setHost(szHost);
+	if (!uRemotePort) uRemotePort=80;
+	kvs_uint_t id=0;
+	QHttp::ConnectionMode mode;
+	if(url.scheme().toLower()=="https")  mode=QHttp::ConnectionModeHttps;
+	else {mode=QHttp::ConnectionModeHttp;url.setScheme("http");}
+	if (mode==QHttp::ConnectionModeHttps) uRemotePort=443;
+	if (m_pHttp) id=m_pHttp->setHost(url.host(), mode, uRemotePort);
+	c->returnValue()->setInteger(id);
+	return true;
+}
+bool  KviKvsObject_http::functionSetUser(KviKvsObjectFunctionCall *c)
+{
+	QString szUser;
+	QString szPass;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("user",KVS_PT_STRING,0,szUser)
+		KVSO_PARAMETER("password",KVS_PT_STRING,0,szPass)
+	KVSO_PARAMETERS_END(c)
+	kvs_int_t id;
+	if (m_pHttp) id=m_pHttp->setUser(szUser,szPass);
+	return true;
+}
+bool  KviKvsObject_http::functionSetProxy(KviKvsObjectFunctionCall *c)
+{
+	QString szHost;
+	QString szUser,szPass;
+	kvs_uint_t uRemotePort;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("host",KVS_PT_STRING,0,szHost)
+		KVSO_PARAMETER("remote_port",KVS_PT_UNSIGNEDINTEGER,KVS_PF_OPTIONAL,uRemotePort)
+		KVSO_PARAMETER("user",KVS_PT_STRING,KVS_PF_OPTIONAL,szUser)
+		KVSO_PARAMETER("pass",KVS_PT_STRING,KVS_PF_OPTIONAL,szPass)
+	KVSO_PARAMETERS_END(c)
+	if (m_pHttp) m_pHttp->setProxy(szHost,uRemotePort,szUser,szPass);
+	return true;
+}
+bool  KviKvsObject_http::functionGet(KviKvsObjectFunctionCall *c)
+{
+	QString szPath,szDest;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("remote_path",KVS_PT_STRING,0,szPath)
+		KVSO_PARAMETER("local_filename",KVS_PT_STRING,0,szDest)
+	KVSO_PARAMETERS_END(c)
+	QFile *pFile=0;
+	if (!szDest.isEmpty()){
+		pFile=new QFile(szDest);
+		if (pFile){
+				pFile->open(QIODevice::WriteOnly);
+		}
+	}
+	int id=0;
+	if (szPath.isEmpty()) szPath="/";
+	if (m_pHttp)
+	{
+		id=m_pHttp->get(szPath,pFile);
+		if (pFile) getDict[id]=pFile;
+		c->returnValue()->setInteger(id);
+	}
+	return true;
+}
+bool  KviKvsObject_http::functionPost(KviKvsObjectFunctionCall *c)
+{
+	QString szPath,szDest,szData;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("remote_path",KVS_PT_STRING,0,szPath)
+		KVSO_PARAMETER("remote_path",KVS_PT_STRING,0,szData)
+		KVSO_PARAMETER("local_filename",KVS_PT_STRING,0,szDest)
+	KVSO_PARAMETERS_END(c)
+	QFile *pFile=0;
+	if (!szDest.isEmpty()){
+		pFile=new QFile(szDest);
+		if (pFile){
+				pFile->open(QIODevice::WriteOnly);
+		}
+	}
+	int id=0;
+	if (szPath.isEmpty()) szPath="/";
+	if (m_pHttp)
+	{
+		id=m_pHttp->post(szPath,szDest.toAscii(),pFile);
+		if (pFile) getDict[id]=pFile;
+		c->returnValue()->setInteger(id);
+	}
+	return true;
+}
+bool  KviKvsObject_http::functionAbort(KviKvsObjectFunctionCall *c)
+{
+	m_bAbort=true;
+	if (m_pHttp) m_pHttp->abort();
+	return true;
+}
+bool  KviKvsObject_http::functionReadAll(KviKvsObjectFunctionCall *c)
+{
+	if (m_pHttp) c->returnValue()->setString(m_pHttp->readAll());
+	return true;
+}
+bool  KviKvsObject_http::functionErrorString(KviKvsObjectFunctionCall *c)
+{
+	if (m_pHttp) c->returnValue()->setString(m_pHttp->errorString());
+	return true;
+}
+//signals & slots 
+
+bool KviKvsObject_http::functionRequestFinishedEvent(KviKvsObjectFunctionCall *c)
+{
+	emitSignal("requestFinished",c,c->params());
+	return true;
+}
+
+void KviKvsObject_http::slotRequestFinished ( int id, bool error )

+{

+    if (m_bAbort) 

+	{

+		m_bAbort=false;

+		QHashIterator<int,QFile *> t(getDict);

+		while (t.hasNext()) 

+		{

+			t.next();

+			int key=t.key();

+			QFile *pFile=getDict.value(key);

+			pFile->close();

+			delete pFile;

+		}

+		getDict.clear();

+		return;

+    }

+	QFile *pFile=getDict.value(id);

+	if (pFile){

+	pFile->close();

+	getDict.remove(id);

+	delete pFile;

+	}

+	callFunction(this,"requestFinishedEvent",0,new KviKvsVariantList(new KviKvsVariant((kvs_int_t) id),new KviKvsVariant(error)));

+

+}

+

+bool KviKvsObject_http::functionRequestStartedEvent(KviKvsObjectFunctionCall *c)
+{
+	emitSignal("requestStarted",c,c->params());
+	return true;
+}

+void KviKvsObject_http::slotRequestStarted ( int id )

+{

+	callFunction(this,"requestStartedEvent",0,new KviKvsVariantList(new KviKvsVariant((kvs_int_t) id)));

+}

+

+void KviKvsObject_http::slotDataReadProgress ( int done,int total )

+{

+	callFunction(this,"dataReadProgressEvent",0,new KviKvsVariantList(
+		new KviKvsVariant((kvs_int_t)done),new KviKvsVariant((kvs_int_t)total)));

+}

+bool KviKvsObject_http::functionDataReadProgressEvent(KviKvsObjectFunctionCall *c)
+{
+	emitSignal("dataReadProgress",c,c->params());
+	return true;
+}

+void KviKvsObject_http::slotDataSendProgress ( int done,int total )

+{

+	callFunction(this,"dataSendProgressEvent",0,new KviKvsVariantList(
+		new KviKvsVariant((kvs_int_t)done),new KviKvsVariant((kvs_int_t)total)));

+}

+bool KviKvsObject_http::functionDataSendProgressEvent(KviKvsObjectFunctionCall *c)
+{
+	emitSignal("dataSendProgress",c,c->params());
+	return true;
+}

+bool KviKvsObject_http::functionDoneEvent(KviKvsObjectFunctionCall *c)

+{

+	emitSignal("done",c,c->params());
+	return true;
+}

+void KviKvsObject_http::slotDone ( bool error )

+{

+	callFunction(this,"doneEvent",0,new KviKvsVariantList(new KviKvsVariant(error)));

+

+}

+

+bool KviKvsObject_http::functionResponseHeaderReceivedEvent(KviKvsObjectFunctionCall *c)
+{
+	emitSignal("requestStarted",c,c->params());
+	return true;
+}

+bool KviKvsObject_http::functionReadyReadEvent(KviKvsObjectFunctionCall *c)
+{
+	emitSignal("readyRead",c,c->params());
+	return true;
+}

+void KviKvsObject_http::slotResponseHeaderReceived(const QHttpResponseHeader &r)
+{
+	QString szResponse;
+	switch (r.statusCode()) {

+		case 200:	szResponse="Ok"  ;break;

+		case 301:	szResponse="Moved Permanently" ;break;

+		case 302:	szResponse="Found" ;break;

+		case 303:	szResponse="See Other" ;break;

+		case 307:	szResponse="Temporary Redirect" ;break;

+		default: szResponse=r.reasonPhrase();
+			m_bAbort=true;
+	}
+	callFunction(this,"responseHeaderReceivedEvent",0,new KviKvsVariantList(
+		new KviKvsVariant(szResponse)));

+}

+void KviKvsObject_http::slotReadyRead(const QHttpResponseHeader &r)
+{
+	QString szResponse;
+	switch (r.statusCode()) {

+		case 200:	szResponse="Ok"  ;break;

+		case 301:	szResponse="Moved Permanently" ;break;

+		case 302:	szResponse="Found" ;break;

+		case 303:	szResponse="See Other" ;break;

+		case 307:	szResponse="Temporary Redirect" ;break;

+		default: szResponse=r.reasonPhrase();
+			m_bAbort=true;
+	}
+	callFunction(this,"readyReadEvent",0,new KviKvsVariantList(
+		new KviKvsVariant(szResponse)));

+}

+

+

+

+

+void KviKvsObject_http::slotStateChanged ( int state)

+{

+	QString szState="";

+	if (state==QHttp::Unconnected) szState="Unconnected";

+	else if (state==QHttp::HostLookup) szState="HostLookup";

+	else if (state==QHttp::Connecting) szState="Connecting";

+	else if (state==QHttp::Connected) szState="Connected";

+	else if (state==QHttp::Sending) szState="Sending";

+	else if (state==QHttp::Reading) szState="Reading";

+

+	else if (state==QHttp::Closing) szState="Closing";

+	callFunction(this,"stateChangedEvent",0,new KviKvsVariantList(
+		new KviKvsVariant(szState)));

+}

+bool KviKvsObject_http::functionStateChangedEvent(KviKvsObjectFunctionCall *c)
+{
+	emitSignal("stateChanged",c,c->params());
+	return true;
+}

+

+#ifndef QT_NO_OPENSSL

+
+bool  KviKvsObject_http::functionIgnoreSslErrors(KviKvsObjectFunctionCall *c)
+{
+	if (m_pHttp) m_pHttp->ignoreSslErrors();
+	return true;
+}
+void KviKvsObject_http::slotSslErrors(QList<QSslError> sslerrors)
+{
+	KviKvsArray *pArray=0;
+	pArray=new KviKvsArray();
+	for(int i=0;i<sslerrors.count();i++)
+	{
+		pArray->set(i,new KviKvsVariant(ssl_errors_tbl[sslerrors.at(i).error()]));
+	}
+	callFunction(this,"sslErrorsEvent",0,new KviKvsVariantList(new KviKvsVariant(pArray)));

+}

+

+bool KviKvsObject_http::functionSslErrorsEvent(KviKvsObjectFunctionCall *c)
+{
+
+	emitSignal("sslErrors",c,c->params());
+	return true;
+}

+#endif

+#ifndef COMPILE_USE_STANDALONE_MOC_SOURCES
+#include "m_class_http.moc"
+#endif //!COMPILE_USE_STANDALONE_MOC_SOURCES
diff --git a/src/modules/objects/class_http.h b/src/modules/objects/class_http.h
new file mode 100644
index 000000000..197250117
--- /dev/null
+++ b/src/modules/objects/class_http.h
@@ -0,0 +1,83 @@
+#ifndef _CLASS_HTTP_H_
+#define _CLASS_HTTP_H_
+//
+//   File : class_http.h
+//   Creation date : Fry Sep 5 18:13:45 2008 GMT by Carbone Alesssandro
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 2001 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. ,59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+
+
+
+
+//===============================================================
+#include "object_macros.h"
+#include <QHttp>
+#include <QFile>
+#include <QHash>
+class KviKvsObject_http : public KviKvsObject
+{
+	Q_OBJECT
+public:
+	KVSO_DECLARE_OBJECT(KviKvsObject_http)
+protected:
+	QHttp *m_pHttp;
+//	QFile *m_pFile;
+	QHash<int, QFile*> getDict;
+	int m_id;
+	bool m_bAbort;
+protected:
+	bool functionSetHost(KviKvsObjectFunctionCall *c);
+	bool functionGet(KviKvsObjectFunctionCall *c);
+	bool functionSetUser(KviKvsObjectFunctionCall *c);
+	bool functionSetProxy(KviKvsObjectFunctionCall *c);
+	bool functionRequestFinishedEvent(KviKvsObjectFunctionCall *c);
+	bool functionRequestStartedEvent(KviKvsObjectFunctionCall *c);
+	bool functionDataReadProgressEvent(KviKvsObjectFunctionCall *c);
+	bool functionDataSendProgressEvent(KviKvsObjectFunctionCall *c);
+	bool functionResponseHeaderReceivedEvent(KviKvsObjectFunctionCall *c);
+	bool functionAbort(KviKvsObjectFunctionCall *c);
+	bool functionDoneEvent(KviKvsObjectFunctionCall *c);
+	bool functionStateChangedEvent(KviKvsObjectFunctionCall *c);
+	bool functionReadAll(KviKvsObjectFunctionCall *c);
+	bool functionReadyReadEvent(KviKvsObjectFunctionCall *c);
+	bool functionErrorString(KviKvsObjectFunctionCall *c);
+	bool functionPost(KviKvsObjectFunctionCall *c);
+	
+	#ifndef QT_NO_OPENSSL
+	bool functionIgnoreSslErrors(KviKvsObjectFunctionCall *c);
+	bool functionSslErrorsEvent(KviKvsObjectFunctionCall *c);
+	#endif
+
+protected slots:
+	void slotRequestFinished ( int id, bool error );

+	void slotDone (bool error );

+	void slotRequestStarted ( int id );

+	void slotDataSendProgress ( int done, int total );

+	void slotDataReadProgress ( int done, int total );

+	#ifndef QT_NO_OPENSSL
+	void slotSslErrors(QList<QSslError>);

+#endif

+	void slotResponseHeaderReceived(const QHttpResponseHeader &r);

+	void slotReadyRead(const QHttpResponseHeader &r);

+	void slotStateChanged ( int state);

+

+

+
+};
+#endif //_CLASS_HTTP_H_
diff --git a/src/modules/objects/class_layout.cpp b/src/modules/objects/class_layout.cpp
index 152e2f29c..a73f6da8b 100644
--- a/src/modules/objects/class_layout.cpp
+++ b/src/modules/objects/class_layout.cpp
@@ -31,6 +31,29 @@
 #define QLAYOUT_MINIMUM QLayout::SetMinimumSize
 
 
+// Tables used in $setAlignment & $alignment
+const char * const align_tbl[] = {
+			"Left", 
+			"Right",
+			"HCenter",
+			"VCenter",
+			"Center",
+			"Top",
+			"Bottom",
+			   };
+
+
+
+const int align_cod[] = {
+		Qt::AlignLeft,
+		Qt::AlignRight,
+	    Qt::AlignHCenter,
+	    Qt::AlignVCenter,
+	    Qt::AlignCenter,
+	 	Qt::AlignTop,
+	    Qt::AlignBottom,
+	};
+#define align_num	(sizeof(align_tbl) / sizeof(align_tbl[0]))
 /*
 	@doc: layout
 	@keyterms:
@@ -71,6 +94,9 @@
 		Sets the default spacing of the widgets in pixels
 		!fn: $setMargin(<margin:uint>)
 		Sets the dimension of the layout margin : the distance from the border to the outermost child widget edges.
+		!fn: $setAlignment(<flag1:string>, <flag2:string>, ...)
+		Sets the alignment for widget w to  flags, given as parameters. 
+		Valid flags are:Right,Left,Top,Bottom,HCenter,VCenter,Center  
 		!fn: $setResizeMode(<resize_mode:string>)
 		Sets the resize mode of the parent widget in relation to this layout.
 		<mode> can be one of:[br]
@@ -91,6 +117,7 @@ KVSO_BEGIN_REGISTERCLASS(KviKvsObject_layout,"layout","object")
 	KVSO_REGISTER_HANDLER(KviKvsObject_layout,"setMargin", functionSetMargin)
 	KVSO_REGISTER_HANDLER(KviKvsObject_layout,"setSpacing", functionSetSpacing)
 	KVSO_REGISTER_HANDLER(KviKvsObject_layout,"setResizeMode", functionSetResizeMode)
+	KVSO_REGISTER_HANDLER(KviKvsObject_layout,"setAlignment", functionsetAlignment )
 KVSO_END_REGISTERCLASS(KviKvsObject_layout)
 
 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_layout,KviKvsObject)
@@ -264,3 +291,59 @@ bool KviKvsObject_layout::functionSetResizeMode(KviKvsObjectFunctionCall *c)
 	return true;
 
 }
+
+bool KviKvsObject_layout::functionsetAlignment(KviKvsObjectFunctionCall *c)
+{
+	QStringList alignment;
+	KviKvsObject * pObject;
+	kvs_hobject_t hObject;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("widget",KVS_PT_HOBJECT,0,hObject)
+		KVSO_PARAMETER("alignment",KVS_PT_STRINGLIST,KVS_PF_OPTIONAL,alignment)
+	KVSO_PARAMETERS_END(c)
+	pObject=KviKvsKernel::instance()->objectController()->lookupObject(hObject);
+	if(!widget())return true;
+	if (!pObject)
+	{
+		c->warning(__tr2qs("Widget parameter is not an object"));
+		return true;
+	}
+	if (!pObject->object())
+	{
+		c->warning(__tr2qs("Widget parameter is not a valid object"));
+		return true;
+	}
+	if(!pObject->object()->isWidgetType())
+	{
+		c->warning(__tr2qs("Can't add a non-widget object"));
+		return true;
+	}
+	int index=((QGridLayout *)widget())->indexOf(((QWidget *)(pObject->object())));
+	if(index ==-1)
+	{
+		c->warning(__tr2qs("The widget must be a child of this hbox"));
+		return true;
+	}
+
+	int align,sum=0;
+	for ( QStringList::Iterator it = alignment.begin(); it != alignment.end(); ++it )
+		{
+		
+			align = 0;
+			for(unsigned int j = 0; j < align_num; j++)
+			{
+				if(KviQString::equalCI((*it), align_tbl[j]))
+				{
+					align=align_cod[j];
+					break;
+				}
+			}
+			if(align)
+				sum = sum | align;
+			else
+				c->warning(__tr2qs("Unknown alignment: '%Q'"),&(*it));
+			
+		}
+	if (widget()) ((QGridLayout *)widget())->setAlignment(((QWidget *)(pObject->object())),(Qt::Alignment)sum);
+	return true;
+}
\ No newline at end of file
diff --git a/src/modules/objects/class_layout.h b/src/modules/objects/class_layout.h
index 5adca51a7..3c0a2428b 100644
--- a/src/modules/objects/class_layout.h
+++ b/src/modules/objects/class_layout.h
@@ -42,6 +42,7 @@ protected:
 	bool functionAddRowSpacing(KviKvsObjectFunctionCall *c);
 	bool functionAddColSpacing(KviKvsObjectFunctionCall *c);
 	bool functionSetResizeMode(KviKvsObjectFunctionCall *c);
+	bool functionsetAlignment(KviKvsObjectFunctionCall *c);
 
 
 };
diff --git a/src/modules/objects/class_lineedit.cpp b/src/modules/objects/class_lineedit.cpp
index 155f31bbc..7776acd42 100644
--- a/src/modules/objects/class_lineedit.cpp
+++ b/src/modules/objects/class_lineedit.cpp
@@ -25,7 +25,7 @@
 #include "kvi_debug.h"
 #include "kvi_locale.h"
 #include "class_lineedit.h"
-
+ #include <QRegExpValidator>
 #include <QLineEdit>
 static const char * mode_tbl[] = {
 			"Normal",
@@ -191,6 +191,8 @@ KVSO_BEGIN_REGISTERCLASS(KviKvsObject_lineedit,"lineedit","widget")
 	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"cut", functionCut)
 	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"paste", functionPaste)
 
+
+
 	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"echoMode", functionEchoMode)
 	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"setEchoMode", functionSetEchoMode)
 	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"clear", functionClear)
@@ -201,6 +203,8 @@ KVSO_BEGIN_REGISTERCLASS(KviKvsObject_lineedit,"lineedit","widget")
 	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"lostFocusEvent", functionlostFocusEvent)
 	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"textChangedEvent", functiontextChangedEvent)
 
+	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"setInputValidator", functionsetInputValidator)
+
 
 KVSO_END_REGISTERCLASS(KviKvsObject_lineedit)
 
@@ -241,7 +245,16 @@ bool KviKvsObject_lineedit::functionSetText(KviKvsObjectFunctionCall *c)
 		((QLineEdit *)widget())->setText(szText);
 	return true;
 }
-
+bool KviKvsObject_lineedit::functionsetInputValidator(KviKvsObjectFunctionCall *c)
+{
+	QString szReg;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("reg_expression",KVS_PT_STRING,0,szReg)
+	KVSO_PARAMETERS_END(c)
+	if (widget())
+		((QLineEdit *)widget())->setValidator(new QRegExpValidator(QRegExp(szReg),((QLineEdit *)widget())));
+	return true;
+}
 bool KviKvsObject_lineedit::functionMaxLength(KviKvsObjectFunctionCall *c)
 {
 	if(widget())
diff --git a/src/modules/objects/class_lineedit.h b/src/modules/objects/class_lineedit.h
index 60c95e576..36313cdeb 100644
--- a/src/modules/objects/class_lineedit.h
+++ b/src/modules/objects/class_lineedit.h
@@ -69,6 +69,8 @@ protected:
 
 	bool functiontextChangedEvent(KviKvsObjectFunctionCall *c);
 
+
+	bool functionsetInputValidator(KviKvsObjectFunctionCall *c);
 protected slots:
 	void slotreturnPressed();
 	void slotlostFocus();
diff --git a/src/modules/objects/class_list.cpp b/src/modules/objects/class_list.cpp
index d9a3fd77f..182009aa9 100644
--- a/src/modules/objects/class_list.cpp
+++ b/src/modules/objects/class_list.cpp
@@ -174,12 +174,12 @@ KVSO_END_CONSTRUCTOR(KviKvsObject_list)
 
 bool KviKvsObject_list::function_current(KviKvsObjectFunctionCall *c)
 {
-	if(!m_pDataList)
+	if(!m_pDataList|!m_pDataList->count())
 	{
 		c->returnValue()->setNothing();
 		return true;
 	}
-	KviKvsVariant * v = m_pDataList->current();
+	KviKvsVariant * v = m_pDataList->safeCurrent();
 	if(v)c->returnValue()->copyFrom(*v);
 	else c->returnValue()->setNothing();
 	return true;
@@ -343,6 +343,8 @@ bool KviKvsObject_list::function_append(KviKvsObjectFunctionCall *c)
 	KVSO_PARAMETERS_END(c)
 	if(!m_pDataList)return true;
 	m_pDataList->append(new KviKvsVariant(*pVar));
+	if (m_pDataList->count()==1) m_pDataList->first();
+
 	return true;
 }
 
diff --git a/src/modules/objects/class_listview.cpp b/src/modules/objects/class_listview.cpp
index 5f006d461..f03090d63 100644
--- a/src/modules/objects/class_listview.cpp
+++ b/src/modules/objects/class_listview.cpp
@@ -191,7 +191,10 @@ KVSO_BEGIN_REGISTERCLASS(KviKvsObject_treewidget,"listview","widget")
 	KVSO_REGISTER_HANDLER(KviKvsObject_treewidget,"setRootIsDecorated",function_setRootIsDecorated)
 	KVSO_REGISTER_HANDLER(KviKvsObject_treewidget,"setAllColumnsShowFocus",function_setAllColumnsShowFocus)
 	KVSO_REGISTER_HANDLER(KviKvsObject_treewidget,"clear",function_clear)
-	KVSO_REGISTER_HANDLER(KviKvsObject_treewidget,"selectedItem",function_selectedItems)
+	//FIXME 
+	KVSO_REGISTER_HANDLER(KviKvsObject_treewidget,"selectedItem",function_selectedItems)//<--- remove this
+	KVSO_REGISTER_HANDLER(KviKvsObject_treewidget,"selectedItems",function_selectedItems)
+
 	KVSO_REGISTER_HANDLER(KviKvsObject_treewidget,"currentItem",function_currentItem)
 	KVSO_REGISTER_HANDLER(KviKvsObject_treewidget,"setSelectionMode",function_setSelectionMode)
 	KVSO_REGISTER_HANDLER(KviKvsObject_treewidget,"listViewHeaderIsVisible",function_listViewHeaderIsVisible)
@@ -219,7 +222,8 @@ KVSO_BEGIN_REGISTERCLASS(KviKvsObject_treewidget,"listview","widget")
 	KVSO_REGISTER_HANDLER(KviKvsObject_treewidget,"itemChangedEvent",function_itemChangedEvent);
 	//
 	
-	KVSO_REGISTER_HANDLER(KviKvsObject_treewidget,"rightButtonClickedEvent",function_rightButtonClickedEvent);
+	KVSO_REGISTER_HANDLER(KviKvsObject_treewidget,"rightButtonClickedEvent",function_customContextMenuRequestedEvent);
+	KVSO_REGISTER_HANDLER(KviKvsObject_treewidget,"customContextMenuRequestedEvent",function_customContextMenuRequestedEvent);
 
 	KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_treewidget,"fileDroppedEvent")
 
@@ -550,9 +554,10 @@ void KviKvsObject_treewidget::slotItemCollapsed(KviTalTreeWidgetItem * i)
 	callFunction(this,"itemCollapsedEvent",0,&params);
 }
 
-bool KviKvsObject_treewidget::function_rightButtonClickedEvent(KviKvsObjectFunctionCall *c)
+bool KviKvsObject_treewidget::function_customContextMenuRequestedEvent(KviKvsObjectFunctionCall *c)
 {
 	emitSignal("rightButtonClicked",c,c->params());
+	emitSignal("customContextMenuRequested",c,c->params());
 	return true;
 }
 
@@ -562,7 +567,7 @@ void KviKvsObject_treewidget::customContextMenuRequested(const QPoint &pnt)
 	KviKvsVariant *ypos=new KviKvsVariant((kvs_int_t)pnt.y());
 	KviTalTreeWidgetItem *it=(KviTalTreeWidgetItem *) ((KviTalTreeWidget *)widget())->itemAt(pnt);
 	KviKvsVariantList params(new KviKvsVariant(KviKvsObject_treewidgetitem::itemToHandle(it)),xpos,ypos);
-	callFunction(this,"rightButtonClickedEvent",0,&params);
+	callFunction(this,"customContextMenuRequestedEvent",0,&params);
 }
 
 bool KviKvsObject_treewidget::function_itemChangedEvent(KviKvsObjectFunctionCall *c)
diff --git a/src/modules/objects/class_listview.h b/src/modules/objects/class_listview.h
index 4c8773b93..d7fa09d5c 100644
--- a/src/modules/objects/class_listview.h
+++ b/src/modules/objects/class_listview.h
@@ -59,7 +59,7 @@ protected:
 	bool function_itemExpandedEvent(KviKvsObjectFunctionCall *c);
 	bool function_itemCollapsedEvent(KviKvsObjectFunctionCall *c);
 	bool function_itemChangedEvent(KviKvsObjectFunctionCall *c);
-	bool function_rightButtonClickedEvent(KviKvsObjectFunctionCall *c);
+	bool function_customContextMenuRequestedEvent(KviKvsObjectFunctionCall *c);
 	bool function_selectedItems(KviKvsObjectFunctionCall *c);
 	bool function_currentItem(KviKvsObjectFunctionCall *c);
 	bool function_setSelectionMode(KviKvsObjectFunctionCall *c);
diff --git a/src/modules/objects/class_listviewitem.cpp b/src/modules/objects/class_listviewitem.cpp
index 286ae8f59..e9eacd56c 100644
--- a/src/modules/objects/class_listviewitem.cpp
+++ b/src/modules/objects/class_listviewitem.cpp
@@ -262,7 +262,6 @@ bool KviKvsObject_treewidgetitem::function_nextSibling(KviKvsObjectFunctionCall
 	return true;
 }
 */
-
 bool KviKvsObject_treewidgetitem::function_setRenameEnabled(KviKvsObjectFunctionCall *c)
 {
 	kvs_uint_t uCol;
diff --git a/src/modules/objects/class_painter.cpp b/src/modules/objects/class_painter.cpp
index 322123fc8..48a078831 100644
--- a/src/modules/objects/class_painter.cpp
+++ b/src/modules/objects/class_painter.cpp
@@ -449,6 +449,8 @@ KVSO_BEGIN_REGISTERCLASS(KviKvsObject_painter,"painter","object")
 	KVSO_REGISTER_HANDLER(KviKvsObject_painter,"save",functionsave)

 	KVSO_REGISTER_HANDLER(KviKvsObject_painter,"restore",functionrestore)

 

+	KVSO_REGISTER_HANDLER(KviKvsObject_painter,"beginPdf",functionBeginPdf)// FIXME: needs doc!

+//bool KviKvsObject_painter::functionBeginPdf(KviKvsObjectFunctionCall *c)

 //QT4

 

 	KVSO_REGISTER_HANDLER(KviKvsObject_painter,"setOpacity",functionsetOpacity)

@@ -476,6 +478,8 @@ KVSO_BEGIN_REGISTERCLASS(KviKvsObject_painter,"painter","object")
 	KVSO_REGISTER_HANDLER(KviKvsObject_painter,"setPenJoinStyle",functionsetPenJoinStyle)

 	KVSO_REGISTER_HANDLER(KviKvsObject_painter,"setPenCapStyle",functionsetPenCapStyle)

 

+	KVSO_REGISTER_HANDLER(KviKvsObject_painter,"painterDeviceWidth",functionwidth)

+	KVSO_REGISTER_HANDLER(KviKvsObject_painter,"painterDeviceHeight",functionheight)

 

 //

 

@@ -489,6 +493,7 @@ KVSO_END_REGISTERCLASS(KviKvsObject_painter)
 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_painter,KviKvsObject)

 

 	m_pPainter = new QPainter();

+	m_pPrinter = 0 ;

 	m_pDeviceObject=0;

 	m_pPainterPath=0;

 	m_pGradient=0;

@@ -503,7 +508,8 @@ if (m_pGradient) delete m_pGradient;
 	m_pGradient=0;

 if (m_pPainter) delete m_pPainter;

 	m_pPainter = 0;

-

+if (m_pPrinter) delete m_pPrinter;

+	m_pPrinter = 0;

 

 KVSO_END_CONSTRUCTOR(KviKvsObject_painter)

 

@@ -1047,16 +1053,27 @@ bool KviKvsObject_painter::functionend(KviKvsObjectFunctionCall *c)
 	detachDevice();

 	return true;

 }

-

+bool KviKvsObject_painter::functionBeginPdf(KviKvsObjectFunctionCall *c)

+{

+	QString szFileName;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("file_name",KVS_PT_STRING,0,szFileName)
+	KVSO_PARAMETERS_END(c)

+	if (m_pPrinter) delete m_pPrinter;

+	m_pPrinter=new QPrinter();//QPrinter::HighResolution);

+	m_pPrinter->setOutputFormat(QPrinter::PdfFormat);

+	m_pPrinter->setOutputFileName(szFileName);

+	m_pPainter->begin(m_pPrinter);

+	return true;

+} 

 bool KviKvsObject_painter::functiondrawText(KviKvsObjectFunctionCall *c)

 {

 	QString szText,szMode;

-	kvs_int_t iX,iY,iLen;

+	kvs_int_t iX,iY;

 	KVSO_PARAMETERS_BEGIN(c)

 		KVSO_PARAMETER("x",KVS_PT_INT,0,iX)

 		KVSO_PARAMETER("y",KVS_PT_INT,0,iY)

 		KVSO_PARAMETER("text",KVS_PT_STRING,0,szText)

-		KVSO_PARAMETER("length",KVS_PT_INT,0,iLen)

 		KVSO_PARAMETER("mode",KVS_PT_STRING,KVS_PF_OPTIONAL,szMode)

 	KVSO_PARAMETERS_END(c)

 	if(!m_pPainter)return true;

@@ -1554,7 +1571,18 @@ bool KviKvsObject_painter::functioncolorNames(KviKvsObjectFunctionCall *c)
 	c->returnValue()->setArray(a);

 	return true;

 }

-

+bool KviKvsObject_painter::functionwidth(KviKvsObjectFunctionCall *c)

+{

+	kvs_int_t width=m_pPainter->device()->width();

+	c->returnValue()->setInteger(width);

+	return true;

+}

+bool KviKvsObject_painter::functionheight(KviKvsObjectFunctionCall *c)

+{

+	kvs_int_t height=m_pPainter->device()->height();

+	c->returnValue()->setInteger(height);

+	return true;

+}

 bool KviKvsObject_painter::functionpathMoveTo(KviKvsObjectFunctionCall *c)

 {

 	kvs_real_t dX,dY;

diff --git a/src/modules/objects/class_painter.h b/src/modules/objects/class_painter.h
index 3229e2375..08dbd3b30 100644
--- a/src/modules/objects/class_painter.h
+++ b/src/modules/objects/class_painter.h
@@ -21,7 +21,7 @@
 //   along with this program. If not, write to the Free Software Foundation,

 //   Inc. ,59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

 //

-

+#include <QPrinter>

 

 #include <qpainter.h>

 #include <qpaintdevice.h>

@@ -36,6 +36,7 @@ class KviKvsObject_painter : public KviKvsObject
 public:

 	KVSO_DECLARE_OBJECT(KviKvsObject_painter)

 protected:

+	QPrinter * m_pPrinter;

 	QPainter * m_pPainter;

 	QMatrix  m_pMatrix;

 	QLinearGradient *m_pGradient;

@@ -105,6 +106,12 @@ public:
 	bool functionpathAddText(KviKvsObjectFunctionCall *c);

 	bool functionresetPath(KviKvsObjectFunctionCall *c);

 

+	bool functionBeginPdf(KviKvsObjectFunctionCall *c);

+	

+	bool functionwidth(KviKvsObjectFunctionCall *c);

+	bool functionheight(KviKvsObjectFunctionCall *c);

+

+

 protected:

 	void attachDevice(KviKvsObject * o,QPaintDevice * p);

 protected slots:

diff --git a/src/modules/objects/class_pixmap.cpp b/src/modules/objects/class_pixmap.cpp
index d0390812c..2b41ab2ec 100644
--- a/src/modules/objects/class_pixmap.cpp
+++ b/src/modules/objects/class_pixmap.cpp
@@ -48,9 +48,16 @@
 		Note that x_offset, y_offest are offsets in the widget.
 		!fn: $resize(<width:integer>,<height:integer>)
 		Resizes the pixmap to w width and h height. Set wh or hg to 0, to have a null pixmap.
-		!fn: $scale(<sx:real>,<sy:real>)
+		!fn: $scale(<width:integer>,<height:integer>,[<aspect_ratio:string>,<transformation_type:string>])
 		Scales the pixmap by sx horizontally and sy vertically.
-		!fn: $rotate(<a:real>)
+		Aspect_ratio values:
+		- IgnoreAspectRatio:the pixmap is scaled ignoring his aspect ratio.
+		- KeepAspectRatio: pixmap is scaled to a rectangle as large as possible inside size, preserving the aspect ratio.

+		- KeepAspectRatioByExpanding, the pixmap is scaled to a rectangle as small as possible outside size, preserving the aspect ratio.
+		Transformation type values:
+		- Fast: fast transformation but less quality.
+		- Smooth: more quality using bilinear filtering.
+		!fn: $rotate(<a:real>) 
 		Rotates the pixmap by a degrees.
 		!fn: $load(<file_name:string>)
 		Load a pixmap from the <file>.
@@ -122,12 +129,25 @@ bool KviKvsObject_pixmap::functionfill(KviKvsObjectFunctionCall *c)
 
 bool KviKvsObject_pixmap::functionscale(KviKvsObjectFunctionCall *c)
 {
-	kvs_real_t uScaleX,uScaleY;
+	kvs_int_t iScaleW,iScaleH;
+	QString szAspectRatio, szTransformation;
 	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("sx",KVS_PT_REAL,0,uScaleX)
-		KVSO_PARAMETER("sy",KVS_PT_REAL,0,uScaleY)
+		KVSO_PARAMETER("new_width",KVS_PT_INTEGER,0,iScaleW)
+		KVSO_PARAMETER("new_height",KVS_PT_INTEGER,0,iScaleH)
+		KVSO_PARAMETER("aspect_ratio",KVS_PT_STRING,KVS_PF_OPTIONAL,szAspectRatio)
+		KVSO_PARAMETER("tranformation_type",KVS_PT_STRING,KVS_PF_OPTIONAL,szTransformation)
 	KVSO_PARAMETERS_END(c)
-	*m_pPixmap = m_pPixmap->scaled((m_pPixmap->width() * uScaleX), (m_pPixmap->height() * uScaleX));
+	Qt::AspectRatioMode ratio=Qt::IgnoreAspectRatio;

+	if (KviQString::equalCI(szAspectRatio,"IgnoreAspectRatio")) ratio=Qt::IgnoreAspectRatio;

+	else if (KviQString::equalCI(szAspectRatio,"KeepAspectRatio")) ratio=Qt::KeepAspectRatio;

+	else if (KviQString::equalCI(szAspectRatio,"KeepAspectRatioByExpanding")) ratio=Qt::KeepAspectRatioByExpanding;

+	else if (!szAspectRatio.isEmpty())c->warning(__tr2qs("Unknown aspect ratio: using default value IgnoreAspectRatio"));
+	Qt::TransformationMode tmode=Qt::FastTransformation;
+	if (KviQString::equalCI(szTransformation,"Fast")) tmode=Qt::FastTransformation;

+	else if (KviQString::equalCI(szTransformation,"Smooth")) tmode=Qt::SmoothTransformation;
+	else if (!szAspectRatio.isEmpty())c->warning(__tr2qs("Unknown tranformation mode: using default value Fast"));
+
+	*m_pPixmap = m_pPixmap->scaled(iScaleW, iScaleH,ratio,tmode);
 	bPixmapModified=true;
 	return true;
 }
diff --git a/src/modules/objects/class_progressbar.cpp b/src/modules/objects/class_progressbar.cpp
index 068f90224..4e8c514bb 100644
--- a/src/modules/objects/class_progressbar.cpp
+++ b/src/modules/objects/class_progressbar.cpp
@@ -67,6 +67,7 @@
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_progressbar,"progressbar","widget")
 	KVSO_REGISTER_HANDLER(KviKvsObject_progressbar,"setProgress", functionSetProgress)
+	KVSO_REGISTER_HANDLER(KviKvsObject_progressbar,"setFormat", functionSetFormat)
 	KVSO_REGISTER_HANDLER(KviKvsObject_progressbar,"setTotalSteps", functionSetTotalSteps)
 	KVSO_REGISTER_HANDLER(KviKvsObject_progressbar,"reset", functionReset)
 	KVSO_REGISTER_HANDLER(KviKvsObject_progressbar,"setPercentageVisible", functionSetPercentageVisible)
@@ -96,17 +97,7 @@ bool KviKvsObject_progressbar::functionSetProgress(KviKvsObjectFunctionCall *c)
 	if (widget()) ((QProgressBar *)widget())->setValue(iValue);
     return true;
 }
-/*
-bool KviKvsObject_progressbar::functionSetProgress(KviKvsObjectFunctionCall *c)
-{
-	kvs_uint_t iValue;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("step_value",KVS_PT_UNSIGNEDINTEGER,0,iValue)
-	KVSO_PARAMETERS_END(c)
-	if (widget()) ((QProgressBar *)widget())->setValue(iValue);
-    return true;
-}
-*/
+
 bool KviKvsObject_progressbar::functionSetTotalSteps(KviKvsObjectFunctionCall *c)
 {
 	kvs_uint_t iMax;
@@ -134,7 +125,16 @@ bool KviKvsObject_progressbar::functionSetPercentageVisible(KviKvsObjectFunction
 		((QProgressBar *)widget())->setTextVisible(bEnabled);
 	return true;
 }
-
+bool KviKvsObject_progressbar::functionSetFormat(KviKvsObjectFunctionCall *c)
+{
+	QString szFormat;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("bEnabled",KVS_PT_STRING,0,szFormat)
+	KVSO_PARAMETERS_END(c)
+	if(widget())
+		((QProgressBar *)widget())->setFormat(szFormat);
+	return true;
+}
 bool KviKvsObject_progressbar::functionPercentageVisible(KviKvsObjectFunctionCall *c)
 {
 	if (widget()) c->returnValue()->setBoolean(((QProgressBar *)widget())->isTextVisible());
diff --git a/src/modules/objects/class_progressbar.h b/src/modules/objects/class_progressbar.h
index b55b8f4e2..6bd96f540 100644
--- a/src/modules/objects/class_progressbar.h
+++ b/src/modules/objects/class_progressbar.h
@@ -42,6 +42,7 @@ protected:
 	bool functionReset(KviKvsObjectFunctionCall *c);
 	bool functionSetPercentageVisible(KviKvsObjectFunctionCall *c);
 	bool functionPercentageVisible(KviKvsObjectFunctionCall *c);
+	bool functionSetFormat(KviKvsObjectFunctionCall *c);
 };
 
 
diff --git a/src/modules/objects/class_socket.cpp b/src/modules/objects/class_socket.cpp
index 9b6d8cd9c..eb489665d 100644
--- a/src/modules/objects/class_socket.cpp
+++ b/src/modules/objects/class_socket.cpp
@@ -44,97 +44,6 @@
 
 #define KVI_IN_BUFFER_ALLOC_CHUNK 4096
 #define KVI_READ_CHUNK 1024
-/*
-static KviScriptObjectClass * g_pSocketClass = 0;
-
-static KviScriptObject * socketClassCreateInstance(KviScriptObjectClass * cls,KviScriptObject *par,const char * nam)
-{
-	return new KviScriptSocketObject(cls,par,nam);
-}
-
-KviScriptSocketObject::KviScriptSocketObject(KviScriptObjectClass * cla,KviScriptObject * par,const char * nam)
-: KviScriptObject(cla,par,nam)
-{
-	m_uConnectionId = 0;
-	m_sock = KVI_INVALID_SOCKET;
-	m_iStatus = KVI_SCRIPT_SOCKET_STATUS_DISCONNECTED;
-	m_uRemotePort = 0;
-	m_uSecondaryPort = 0;
-	m_pSn = 0;
-	m_pDns = 0;
-	m_pDelayTimer = 0;
-	m_uConnectTimeout = 60000;
-	m_pInBuffer = 0;
-	m_uInBufferLen = 0;
-	m_uInDataLen = 0;
-	m_pOutBuffer = new KviDataBuffer();
-	m_pFlushTimer = new QTimer();
-	m_bIPv6 = false;
-	m_uLocalPort = 0;
-	m_secondarySock = KVI_INVALID_SOCKET;
-	connect(m_pFlushTimer,SIGNAL(timeout()),this,SLOT(tryFlush()));
-}
-
-KviScriptSocketObject::~KviScriptSocketObject()
-{
-	delete m_pOutBuffer;
-	delete m_pFlushTimer;
-
-	if(m_pInBuffer)kvi_free(m_pInBuffer);
-	if(m_pDelayTimer)delete m_pDelayTimer;
-	if(m_pDns)delete m_pDns;
-	if(m_pSn)delete m_pSn;
-	if(m_sock != KVI_INVALID_SOCKET)kvi_socket_close(m_sock);
-	if(m_secondarySock != KVI_INVALID_SOCKET)kvi_socket_close(m_secondarySock);
-}
-
-void KviScriptSocketObject::reset()
-{
-	m_uConnectionId++; // this is the only place where this is incremented!
-	if(m_pDelayTimer)
-	{
-		delete m_pDelayTimer;
-		m_pDelayTimer = 0;
-	}
-	if(m_pDns)
-	{
-		delete m_pDns;
-		m_pDns = 0;
-	}
-	if(m_pSn)
-	{
-		delete m_pSn;
-		m_pSn = 0;
-	}
-	if(m_sock != KVI_INVALID_SOCKET)
-	{
-		kvi_socket_close(m_sock);
-		m_sock = KVI_INVALID_SOCKET;
-	}
-	if(m_pInBuffer)
-	{
-		kvi_free(m_pInBuffer);
-		m_pInBuffer = 0;
-	}
-	if(m_secondarySock)
-	{
-		kvi_socket_close(m_secondarySock);
-		m_secondarySock = KVI_INVALID_SOCKET;
-	}
-	m_uSecondaryPort = 0;
-	m_szSecondaryIp.clear();
-	delete m_pOutBuffer;
-	if(m_pFlushTimer->isActive())m_pFlushTimer->stop();
-	m_pOutBuffer = new KviDataBuffer();
-	m_uInBufferLen = 0;
-	m_uInDataLen = 0;
-	m_iStatus = KVI_SCRIPT_SOCKET_STATUS_DISCONNECTED;
-	m_uRemotePort = 0;
-	m_szRemoteIp.clear();
-	m_uLocalPort = 0;
-	m_szLocalIp.clear();
-	m_bIPv6 = false;
-}
 
 /*
 	@doc: socket
diff --git a/src/modules/objects/class_vbox.cpp b/src/modules/objects/class_vbox.cpp
index 77c95030d..9a9cc8cc0 100644
--- a/src/modules/objects/class_vbox.cpp
+++ b/src/modules/objects/class_vbox.cpp
@@ -27,6 +27,34 @@
 #include "class_vbox.h"
 
 #include "kvi_tal_vbox.h"
+
+
+// Tables used in $setAlignment & $alignment
+const char * const align_tbl[] = {
+			"Left", 
+			"Right",
+			"HCenter",
+			"VCenter",
+			"Center",
+			"Top",
+			"Bottom",
+			"WordBreak"
+			   };
+
+
+
+const int align_cod[] = {
+		Qt::AlignLeft,
+		Qt::AlignRight,
+	    Qt::AlignHCenter,
+	    Qt::AlignVCenter,
+	    Qt::AlignCenter,
+	 	Qt::AlignTop,
+	    Qt::AlignBottom,
+	    Qt::AlignJustify,
+	};
+
+#define align_num	(sizeof(align_tbl) / sizeof(align_tbl[0]))
 /*
 	@doc: vbox
 	@keyterms:
@@ -48,6 +76,11 @@
 		Sets the dimension of the layout margin : the distance from the border to the outermost child widget edges.
 		!fn: $setStretchFactor(<widget:hobject>,<stretch:uint>)
 		Sets the stretch factor of widget to stretch.
+		!fn: $addStretch(<stretch:integer>)
+		Adds a stretchable space with zero minimum size and stretch factor stretch to the end of this box layout.
+		!fn: $setAlignment(<flag1:string>, <flag2:string>, ...)
+		Sets the alignment for widget w to  flags, given as parameters. 
+		Valid flags are:Right,Left,Top,Bottom,HCenter,VCenter,Center  
 */
 
 
@@ -55,6 +88,8 @@ KVSO_BEGIN_REGISTERCLASS(KviKvsObject_vbox,"vbox","widget")
 	KVSO_REGISTER_HANDLER(KviKvsObject_vbox,"setMargin", functionsetMargin)
 	KVSO_REGISTER_HANDLER(KviKvsObject_vbox,"setSpacing", functionsetSpacing)
 	KVSO_REGISTER_HANDLER(KviKvsObject_vbox,"setStretchFactor", functionsetStretchFactor )
+	KVSO_REGISTER_HANDLER(KviKvsObject_vbox,"addStretch", functionaddStretch )
+	KVSO_REGISTER_HANDLER(KviKvsObject_vbox,"setAlignment", functionsetAlignment )
 KVSO_END_REGISTERCLASS(KviKvsObject_vbox)
 
 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_vbox,KviKvsObject_widget)
@@ -127,3 +162,67 @@ bool KviKvsObject_vbox::functionsetStretchFactor(KviKvsObjectFunctionCall *c)
 	((KviTalVBox *)widget())->setStretchFactor(((QWidget *)(pObject->object())),uStretch);
 	return true;
 }
+bool KviKvsObject_vbox::functionaddStretch(KviKvsObjectFunctionCall *c)
+{
+	kvs_int_t iStretch;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("stretch",KVS_PT_INT,0,iStretch)
+	KVSO_PARAMETERS_END(c)
+	
+	if (widget())((KviTalVBox *)widget())->addStretch(iStretch);
+	return true;
+}
+bool KviKvsObject_vbox::functionsetAlignment(KviKvsObjectFunctionCall *c)
+{
+	QStringList alignment;
+	KviKvsObject * pObject;
+	kvs_hobject_t hObject;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("widget",KVS_PT_HOBJECT,0,hObject)
+		KVSO_PARAMETER("alignment",KVS_PT_STRINGLIST,KVS_PF_OPTIONAL,alignment)
+	KVSO_PARAMETERS_END(c)
+	pObject=KviKvsKernel::instance()->objectController()->lookupObject(hObject);
+	if(!widget())return true;
+	if (!pObject)
+	{
+		c->warning(__tr2qs("Widget parameter is not an object"));
+		return true;
+	}
+	if (!pObject->object())
+	{
+		c->warning(__tr2qs("Widget parameter is not a valid object"));
+		return true;
+	}
+	if(!pObject->object()->isWidgetType())
+	{
+		c->warning(__tr2qs("Can't add a non-widget object"));
+		return true;
+	}
+	if(((KviKvsObject_widget *)pObject)->widget()->parentWidget() != widget())
+	{
+		c->warning(__tr2qs("The widget must be a child of this hbox"));
+		return true;
+	}
+
+	int align,sum=0;
+	for ( QStringList::Iterator it = alignment.begin(); it != alignment.end(); ++it )
+		{
+		
+			align = 0;
+			for(unsigned int j = 0; j < align_num; j++)
+			{
+				if(KviQString::equalCI((*it), align_tbl[j]))
+				{
+					align=align_cod[j];
+					break;
+				}
+			}
+			if(align)
+				sum = sum | align;
+			else
+				c->warning(__tr2qs("Unknown alignment: '%Q'"),&(*it));
+			
+		}
+	if (widget()) ((KviTalHBox *)widget())->setAlignment(((QWidget *)(pObject->object())),(Qt::Alignment)sum);
+	return true;
+}
\ No newline at end of file
diff --git a/src/modules/objects/class_vbox.h b/src/modules/objects/class_vbox.h
index c9cfe0e90..07382a9d8 100644
--- a/src/modules/objects/class_vbox.h
+++ b/src/modules/objects/class_vbox.h
@@ -36,6 +36,8 @@ protected:
 	bool functionsetMargin(KviKvsObjectFunctionCall *c);
 	bool functionsetSpacing(KviKvsObjectFunctionCall *c);
 	bool functionsetStretchFactor(KviKvsObjectFunctionCall *c);
+	bool functionaddStretch(KviKvsObjectFunctionCall *c);
+	bool functionsetAlignment(KviKvsObjectFunctionCall *c);
 
 };
 
diff --git a/src/modules/objects/class_widget.cpp b/src/modules/objects/class_widget.cpp
index aa94a737b..9dbf8ebf9 100644
--- a/src/modules/objects/class_widget.cpp
+++ b/src/modules/objects/class_widget.cpp
@@ -47,8 +47,8 @@
 #include <QMetaObject>

 #include <QIcon>

 #include <QStatusBar>

-#include <QUiLoader>

-#include <QFile>

+#include <QtWebKit/QWebView>

+#include <QUrl>

 

 KviKvsWidget::KviKvsWidget(KviKvsObject_widget * object,QWidget * par)

 :QWidget(par), m_pObject(object)

@@ -88,6 +88,8 @@ const char * const widgettypes_tbl[] = {
 	"SysMenu",

 	"Minimize",

 	"Maximize",

+	"Subwindow",

+	"FramelessWindow"

 };

 

 const Qt::WidgetAttribute widgetattributes_cod[] = {

@@ -149,6 +151,8 @@ const Qt::WindowType widgettypes_cod[] = {
 	Qt::WindowSystemMenuHint,

 	Qt::WindowMinimizeButtonHint,

 	Qt::WindowMaximizeButtonHint,

+	Qt::SubWindow,

+	Qt::FramelessWindowHint

 };

 

 #define QT_WIDGET_TABFOCUS Qt::TabFocus

@@ -180,9 +184,11 @@ const Qt::WindowType widgettypes_cod[] = {
 		!fn: $hide()

 		Hides this widget (and conseguently all the children).

 		See also [classfnc]$show[/classfnc]() and [classfnc]$isVisible[/classfnc].

-		!fn: $repaint(<bool erase>)

+		!fn: $repaint()

 		Repaints the widget directly by calling [classfnc]$paintEvent[/classfnc]() immediately.[br]

-		If erase is TRUE, erases the widget before the $paintEvent() call.

+		!fn: $update([<x:ingeter>,<y:integer>,<width:integer>,<height:integer>])

+		Updates enterily the widget or a rectangle.

+		This function does not cause an immediate [classfnc]$paintEvent[/classfnc](); instead it schedules a paint event for processing when KVIrc returns to the main event loop.

 		!fn: $x()

 		Returns the x coordinate of the upper-left corner

 		of this widget relative to the parent widget,

@@ -514,10 +520,6 @@ const Qt::WindowType widgettypes_cod[] = {
 		See also [classfnc]$removeFromStatusBar[/classfnc]().

 		!fn: $removeFromStatusBar()

 		Remove the widget from statusbar.

-

-		!fn: $loadInterface(<string:filename>)

-		Loads the interface file "<filename>.ui".

-		The UI file must be created in the proper way using a tool like Qt Designer or KDevelop Designer.

 	@examples:

 		[example]

 			%Widget = $new(widget)

@@ -637,7 +639,6 @@ KVSO_BEGIN_REGISTERCLASS(KviKvsObject_widget,"widget","object")
 	KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setToolTip",function_setToolTip)

 	KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setWFlags",function_setWFlags)

 	KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setIcon",function_setWindowIcon)

-	KVSO_REGISTER_HANDLER(KviKvsObject_widget,"loadInterface",function_loadInterface)

 	// fonts

 	KVSO_REGISTER_HANDLER(KviKvsObject_widget,"fontDescent",function_fontDescent)

 	KVSO_REGISTER_HANDLER(KviKvsObject_widget,"fontAscent",function_fontAscent)

@@ -704,19 +705,25 @@ KVSO_BEGIN_REGISTERCLASS(KviKvsObject_widget,"widget","object")
 	KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"sizeHintRequestEvent")

 	KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"maybeTipEvent")

 	KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"shortCutEvent")

+

+	KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setWebView",function_setWebView)

+

 KVSO_END_REGISTERCLASS(KviKvsObject_widget)

 

+

 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_widget,KviKvsObject)

 KVSO_END_CONSTRUCTOR(KviKvsObject_widget)

 

 KVSO_BEGIN_DESTRUCTOR(KviKvsObject_widget)

 	emit aboutToDie();

+//	if (webview) delete webview;

 KVSO_END_CONSTRUCTOR(KviKvsObject_widget)

 

 bool KviKvsObject_widget::init(KviKvsRunTimeContext * pContext,KviKvsVariantList * pParams)

 {

 	setObject(new KviKvsWidget(this,parentScriptWidget()));

 	widget()->setObjectName(getName());

+	webview=0;

 	return true;

 }

 

@@ -1021,9 +1028,6 @@ bool KviKvsObject_widget::function_fontAscent(KviKvsObjectFunctionCall * c)
 bool KviKvsObject_widget::function_repaint(KviKvsObjectFunctionCall * c)

 {

 	bool bEnabled;

-	KVSO_PARAMETERS_BEGIN(c)

-		KVSO_PARAMETER("bEnabled",KVS_PT_BOOL,0,bEnabled)

-	KVSO_PARAMETERS_END(c)

 	if(!widget()) return true;

 	widget()->repaint();

 	return true;

@@ -1192,7 +1196,19 @@ bool KviKvsObject_widget::function_setPaletteForeground(KviKvsObjectFunctionCall
 		KVSO_PARAMETER("green",KVS_PT_INT,KVS_PF_OPTIONAL,iColG)

 		KVSO_PARAMETER("blue",KVS_PT_INT,KVS_PF_OPTIONAL,iColB)

 	KVSO_PARAMETERS_END(c)

-

+	

+	if(pColArray->isString())

+	{

+		QString szColor;

+		pColArray->asString(szColor);

+		if (widget())

+		{

+			QPalette p = widget()->palette(); 

+			p.setColor(widget()->foregroundRole(), QColor(szColor)); 

+			widget()->setPalette(p); 

+		}

+		return true;

+	}

 	if(pColArray->isArray())

 	{

 		if(pColArray->array()->size() < 3)

@@ -1739,7 +1755,7 @@ bool KviKvsObject_widget::function_addWidgetToWrappedLayout(KviKvsObjectFunction
 	QLayout *lay=widget()->layout();

 	if (!lay)

 	{

-		c->warning(__tr2qs("No Layout associated to the widget"));

+		c->warning(__tr2qs("No Layout associated to the widget "));

 		return true;

 	}

 	if(!ob->object()->isWidgetType())

@@ -1952,32 +1968,19 @@ bool KviKvsObject_widget::function_removeFromStatusBar(KviKvsObjectFunctionCall
 	if (widget()) g_pFrame->statusBar()->removeWidget(widget());

 	return true;

 }

-

-bool KviKvsObject_widget::function_loadInterface(KviKvsObjectFunctionCall *c)

+bool KviKvsObject_widget::function_setWebView(KviKvsObjectFunctionCall *c)

 {

-	QString szFileName;

-	KVSO_PARAMETERS_BEGIN(c)

-		KVSO_PARAMETER("interface_file",KVS_PT_STRING,0,szFileName)

+	QString szUrl;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("text",KVS_PT_STRING,0,szUrl)
 	KVSO_PARAMETERS_END(c)

 

-	QUiLoader loader;

-	QFile file(szFileName);

-	file.open(QFile::ReadOnly);

-	QWidget * pWidget = loader.load(&file,(QWidget *)this);

-	file.close();

-

-	QLayout * pLayout = widget()->layout();

-	if(!pLayout)

-	{

-		c->warning(__tr2qs("No layout associated to the widget"));

-		return true;

-	}

-

-	pLayout->addWidget(pWidget);

-

+	webview=new QWebView(widget());

+	webview->load(QUrl(szUrl));

+    webview->show();

+	//if (widget()) g_pFrame->statusBar()->removeWidget(widget());

 	return true;

 }

-

 #ifndef COMPILE_USE_STANDALONE_MOC_SOURCES

 #include "m_class_widget.moc"

 #endif //!COMPILE_USE_STANDALONE_MOC_SOURCES

diff --git a/src/modules/objects/class_widget.h b/src/modules/objects/class_widget.h
index 850dc82d2..332a3d000 100644
--- a/src/modules/objects/class_widget.h
+++ b/src/modules/objects/class_widget.h
@@ -24,7 +24,7 @@
 #include "kvi_string.h"

 #include "kvi_tal_tooltip.h"

 #include "object_macros.h"

-

+#include <QtWebKit/QWebView>

 class KviKvsObject_widget : public KviKvsObject

 {

 	Q_OBJECT

@@ -36,7 +36,7 @@ public:
 

 protected:

 	virtual bool init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams);

-

+	QWebView *webview;

 	virtual bool eventFilter(QObject *o,QEvent *e);

 

 	// ok, it is clear that we're messing with the naming conventions for the

@@ -108,6 +108,9 @@ protected:
 	bool function_windowTitle(KviKvsObjectFunctionCall *c);

 	bool function_x(KviKvsObjectFunctionCall *);

 	bool function_y(KviKvsObjectFunctionCall *);

+

+	bool function_setWebView(KviKvsObjectFunctionCall *c);

+

 signals:

 	void aboutToDie();

 };

diff --git a/src/modules/objects/libkviobjects.cpp b/src/modules/objects/libkviobjects.cpp
index 5a9881def..fdf0a7040 100644
--- a/src/modules/objects/libkviobjects.cpp
+++ b/src/modules/objects/libkviobjects.cpp
@@ -29,8 +29,10 @@
 #include "class_dialog.h"
 #include "class_dockwindow.h"
 #include "class_file.h"
+#include "class_ftp.h"
 #include "class_groupbox.h"
 #include "class_hbox.h"
+#include "class_http.h"
 #include "class_layout.h"
 #include "class_lcd.h"
 #include "class_lineedit.h"
@@ -88,6 +90,8 @@ static bool objects_module_cleanup(KviModule *m)
 	// Don't attempt to change the order of these calls.
 	// Derived classes must be unregistered before the base ones.
 	KviKvsObject_process::unregisterSelf();
+	KviKvsObject_ftp::unregisterSelf();
+	KviKvsObject_http::unregisterSelf();
 	KviKvsObject_socket::unregisterSelf();
 	KviKvsObject_xmlreader::unregisterSelf();
 	KviKvsObject_wrapper::unregisterSelf();
@@ -986,6 +990,9 @@ static bool objects_module_init(KviModule * m)
 	KviKvsObject_wrapper::registerSelf();
 	KviKvsObject_xmlreader::registerSelf();
 	KviKvsObject_socket::registerSelf();
+	KviKvsObject_http::registerSelf();
+	KviKvsObject_ftp::registerSelf();
+
 	KviKvsObject_process::registerSelf();
 
 	return true;