added doxygen comments;

removed the last COMPILE_USE_QT4 define;
updated TODO and ChangeLog;
minor fixes;


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

19 files changed, 902 insertions, 293 deletions

diff --git a/src/kvirc/kvs/kvi_kvs_script.cpp b/src/kvirc/kvs/kvi_kvs_script.cpp
index 6d3d105c9..d6dff5b94 100644
--- a/src/kvirc/kvs/kvi_kvs_script.cpp
+++ b/src/kvirc/kvs/kvi_kvs_script.cpp
@@ -36,53 +36,41 @@
 #include "kvi_window.h"
 #include "kvi_app.h"
 
-class KVIRC_API KviKvsScriptData
-{
-	friend class KviKvsScript;
-protected:
-	unsigned int                m_uRefs;     // Reference count for this structure
-
-	QString                     m_szName;    // script context name
-	QString                     m_szBuffer;  // NEVER TOUCH THIS
-	const QChar               * m_pBuffer;   // this points to m_szBuffer: use it to extract string data
-
-	KviKvsScript::ScriptType    m_eType;     // the type of the code in m_szBuffer
-
-	KviKvsTreeNodeInstruction * m_pTree;     // syntax tree
-	unsigned int                m_uLock;     // this is increased while the script is being executed
-};
-
 //#warning "THERE IS SOME MESS WITH m_szBuffer and m_pBuffer : with some script copying we may get errors with negative char indexes!"
 
-KviKvsScript::KviKvsScript(const QString &szName,const QString &szBuffer,ScriptType eType)
+KviKvsScript::KviKvsScript(const QString & szName, const QString & szBuffer, ScriptType eType)
 {
 	m_pData = new KviKvsScriptData;
 	m_pData->m_uRefs = 1;
 	m_pData->m_szName = szName;
 	m_pData->m_eType = eType;
 	m_pData->m_szBuffer = szBuffer;
-	if(m_pData->m_szBuffer.isNull())m_pData->m_szBuffer = "";
+	if(m_pData->m_szBuffer.isNull())
+		m_pData->m_szBuffer = "";
+
 	//KviQString::detach(*(m_pData->m_pszBuffer));
 	m_pData->m_pBuffer = KviQString::nullTerminatedArray(m_pData->m_szBuffer); // never 0
 	m_pData->m_uLock = 0;
 	m_pData->m_pTree = 0;
 }
 
-KviKvsScript::KviKvsScript(const QString &szName,const QString &szBuffer,KviKvsTreeNodeInstruction * pPreparsedTree,ScriptType eType)
+KviKvsScript::KviKvsScript(const QString & szName, const QString & szBuffer, KviKvsTreeNodeInstruction * pPreparsedTree, ScriptType eType)
 {
 	m_pData = new KviKvsScriptData;
 	m_pData->m_uRefs = 1;
 	m_pData->m_szName = szName;
 	m_pData->m_szBuffer = szBuffer;
 	m_pData->m_eType = eType;
-	if(m_pData->m_szBuffer.isNull())m_pData->m_szBuffer = "";
+	if(m_pData->m_szBuffer.isNull())
+		m_pData->m_szBuffer = "";
+
 	//KviQString::detach(*(m_pData->m_pszBuffer));
 	m_pData->m_pBuffer = KviQString::nullTerminatedArray(m_pData->m_szBuffer); // never 0
 	m_pData->m_uLock = 0;
 	m_pData->m_pTree = pPreparsedTree;
 }
 
-KviKvsScript::KviKvsScript(const KviKvsScript &src)
+KviKvsScript::KviKvsScript(const KviKvsScript & src)
 {
 	m_pData = src.m_pData;
 	m_pData->m_uRefs++;
@@ -100,9 +88,10 @@ KviKvsScript::~KviKvsScript()
 	}
 }
 
-void KviKvsScript::setName(const QString &szName)
+void KviKvsScript::setName(const QString & szName)
 {
-	if(m_pData->m_uRefs > 1)detach();
+	if(m_pData->m_uRefs > 1)
+		detach();
 	m_pData->m_szName = szName;
 }
 
@@ -123,19 +112,24 @@ bool KviKvsScript::locked() const
 
 void KviKvsScript::dump(const char * prefix)
 {
-	if(m_pData->m_pTree)m_pData->m_pTree->dump(prefix);
+	if(m_pData->m_pTree)
+		m_pData->m_pTree->dump(prefix);
 	else debug("%s KviKvsScript : no tree to dump",prefix);
 }
 
 void KviKvsScript::detach()
 {
-	if(m_pData->m_uRefs <= 1)return;
+	if(m_pData->m_uRefs <= 1)
+		return;
+
 	m_pData->m_uRefs--;
 	KviKvsScriptData * d = new KviKvsScriptData;
 	d->m_uRefs = 1;
 	d->m_eType = m_pData->m_eType;
 	d->m_szBuffer = m_pData->m_szBuffer;
-	if(d->m_szBuffer.isNull())d->m_szBuffer = "";
+	if(d->m_szBuffer.isNull())
+		d->m_szBuffer = "";
+
 	KviQString::detach(d->m_szBuffer);
 	d->m_pBuffer = KviQString::nullTerminatedArray(d->m_szBuffer); // never 0
 	d->m_uLock = 0;
@@ -148,21 +142,21 @@ const QChar * KviKvsScript::buffer() const
 	return m_pData->m_pBuffer;
 }
 
-int KviKvsScript::run(const QString &szCode,KviWindow * pWindow,KviKvsVariantList * pParams,KviKvsVariant * pRetVal)
+int KviKvsScript::run(const QString & szCode, KviWindow * pWindow, KviKvsVariantList * pParams, KviKvsVariant * pRetVal)
 {
 	// static helper
 	KviKvsScript s("kvirc::corecall(run)",szCode);
 	return s.run(pWindow,pParams,pRetVal,PreserveParams);
 }
 
-int KviKvsScript::evaluate(const QString &szCode,KviWindow * pWindow,KviKvsVariantList * pParams,KviKvsVariant * pRetVal)
+int KviKvsScript::evaluate(const QString & szCode, KviWindow * pWindow, KviKvsVariantList * pParams, KviKvsVariant * pRetVal)
 {
 	// static helper
 	KviKvsScript s("kvirc::corecall(evalutate)",szCode,Parameter);
 	return s.run(pWindow,pParams,pRetVal,PreserveParams);
 }
 
-int KviKvsScript::evaluateAsString(const QString &szCode,KviWindow * pWindow,KviKvsVariantList * pParams,QString &szRetVal)
+int KviKvsScript::evaluateAsString(const QString & szCode, KviWindow * pWindow, KviKvsVariantList * pParams, QString & szRetVal)
 {
 	// static helper
 	KviKvsVariant ret;
@@ -172,7 +166,7 @@ int KviKvsScript::evaluateAsString(const QString &szCode,KviWindow * pWindow,Kvi
 	return iRet;
 }
 
-int KviKvsScript::run(KviWindow * pWnd,KviKvsVariantList * pParams,QString &szRetVal,int iRunFlags,KviKvsExtendedRunTimeData * pExtData)
+int KviKvsScript::run(KviWindow * pWnd, KviKvsVariantList * pParams, QString & szRetVal, int iRunFlags, KviKvsExtendedRunTimeData * pExtData)
 {
 	KviKvsVariant retVal;
 	int iRet = run(pWnd,pParams,&retVal,iRunFlags,pExtData);
@@ -183,7 +177,7 @@ int KviKvsScript::run(KviWindow * pWnd,KviKvsVariantList * pParams,QString &szRe
 //static long int g_iTreeCacheHits = 0;
 //static long int g_iTreeCacheMisses = 0;
 
-int KviKvsScript::run(KviWindow * pWnd,KviKvsVariantList * pParams,KviKvsVariant * pRetVal,int iRunFlags,KviKvsExtendedRunTimeData * pExtData)
+int KviKvsScript::run(KviWindow * pWnd, KviKvsVariantList * pParams, KviKvsVariant * pRetVal, int iRunFlags, KviKvsExtendedRunTimeData * pExtData)
 {
 	if(!m_pData->m_pTree)
 	{
@@ -192,7 +186,8 @@ int KviKvsScript::run(KviWindow * pWnd,KviKvsVariantList * pParams,KviKvsVariant
 		//debug("TREE CACHE STATS: HITS=%d, MISSES=%d",g_iTreeCacheHits,g_iTreeCacheMisses);
 		if(!parse(pWnd,iRunFlags))
 		{
-			if(pParams && !(iRunFlags & PreserveParams))delete pParams;
+			if(pParams && !(iRunFlags & PreserveParams))
+				delete pParams;
 			return Error;
 		}
 	} else {
@@ -204,7 +199,7 @@ int KviKvsScript::run(KviWindow * pWnd,KviKvsVariantList * pParams,KviKvsVariant
 	return execute(pWnd,pParams,pRetVal,iRunFlags,pExtData);
 }
 
-int KviKvsScript::run(KviKvsRunTimeContext * pContext,int iRunFlags)
+int KviKvsScript::run(KviKvsRunTimeContext * pContext, int iRunFlags)
 {
 	if(!m_pData->m_pTree)
 	{
@@ -234,8 +229,7 @@ int KviKvsScript::run(KviKvsRunTimeContext * pContext,int iRunFlags)
 	return iRet;
 }
 
-
-bool KviKvsScript::parse(KviWindow * pOutput,int iRunFlags)
+bool KviKvsScript::parse(KviWindow * pOutput, int iRunFlags)
 {
 	if(m_pData->m_pTree)
 	{
@@ -253,7 +247,9 @@ bool KviKvsScript::parse(KviWindow * pOutput,int iRunFlags)
 				debug("WARNING: Trying to reparse a locked KviKvsScript!");
 				return false;
 			}
-			if(m_pData->m_pTree)delete m_pData->m_pTree;
+			if(m_pData->m_pTree)
+				delete m_pData->m_pTree;
+
 			m_pData->m_pTree = 0;
 		}
 	} // else there is no tree at all, nobody can be locked inside
@@ -285,7 +281,6 @@ bool KviKvsScript::parse(KviWindow * pOutput,int iRunFlags)
 	return !p.error();
 }
 
-
 int KviKvsScript::executeInternal(KviKvsRunTimeContext * pContext)
 {
 	// lock this script
@@ -309,18 +304,21 @@ int KviKvsScript::executeInternal(KviKvsRunTimeContext * pContext)
 	return iRunStatus;
 }
 
-int KviKvsScript::execute(KviWindow * pWnd,KviKvsVariantList * pParams,KviKvsVariant * pRetVal,int iRunFlags,KviKvsExtendedRunTimeData * pExtData)
+int KviKvsScript::execute(KviWindow * pWnd, KviKvsVariantList * pParams, KviKvsVariant * pRetVal, int iRunFlags, KviKvsExtendedRunTimeData * pExtData)
 {
 	bool bDeleteParams = !(iRunFlags & PreserveParams);
 
 	// do we have a parsed tree ?
 	if(!m_pData->m_pTree)
 	{
-		if(pParams && bDeleteParams)delete pParams;
+		if(pParams && bDeleteParams)
+			delete pParams;
+
 		// this is intended for developers only
 		pWnd->outputNoFmt(KVI_OUT_PARSERERROR,"[developer error]: you must succesfully call KviKvsScript::parse() before KviKvsScript::execute()");
 		return Error;
 	}
+
 	// do we need to pass dummy params ?
 	if(!pParams)
 	{
@@ -344,8 +342,11 @@ int KviKvsScript::execute(KviWindow * pWnd,KviKvsVariantList * pParams,KviKvsVar
 	int iRunStatus = executeInternal(&ctx);
 
 	// don't forget to delete the params
-	if(bDeleteParams)delete pParams;
-	if(bDeleteRetVal)delete pRetVal;
-    pParams = 0; pRetVal = 0;
+	if(bDeleteParams)
+		delete pParams;
+	if(bDeleteRetVal)
+		delete pRetVal;
+	pParams = 0;
+	pRetVal = 0;
 	return iRunStatus;
 }
diff --git a/src/kvirc/kvs/kvi_kvs_script.h b/src/kvirc/kvs/kvi_kvs_script.h
index d47ec59ec..a59e82fd8 100644
--- a/src/kvirc/kvs/kvi_kvs_script.h
+++ b/src/kvirc/kvs/kvi_kvs_script.h
@@ -24,6 +24,12 @@
 //
 //=============================================================================
 
+/**
+* \file kvi_kvs_script.h
+* \author Szymon Stefanek
+* \brief KVIrc Script manager
+*/
+
 #include "kvi_settings.h"
 #include "kvi_qstring.h"
 #include "kvi_window.h"
@@ -46,110 +52,273 @@ class KviKvsRunTimeContext;
 	#undef Success
 #endif
 
+
+
+
+/**
+* \class KviKvsScript
+* \brief The KVIrc Script class
+*/
 class KVIRC_API KviKvsScript : public KviHeapObject
 {
 	friend class KviKvsObject;
 	friend class KviKvsParser;
 	friend class KviKvsRunTimeContext;
 public:
+	/**
+	* \enum RunStatus
+	*/
 	enum RunStatus {
-		// the script returned an error
-		Error = 0,
-		// the script ran succesfully
-		Success = 1,
-		// the script ran succesfully and halt was encountered
-		HaltEncountered = 2
+		Error = 0, /**< The script returned an error */
+		Success = 1, /**< The script ran succesfully */
+		HaltEncountered = 2 /**< The script ran succesfully and halt was encountered */
 	};
+
+	/**
+	* \enum ScriptType
+	*/
 	enum ScriptType {
-		// the most common script type: a sequence of instructions
-		InstructionList,
-		// an expression to be evaluated as in a $() call (pRetVal should be always set!)
-		Expression,
-		// a parameter to be evaluated (pRetVal should be always set!)
-		Parameter
+		InstructionList, /**< The most common script type: a sequence of instructions */
+		Expression, /**< An expression to be evaluated as in a $() call (pRetVal should be always set!) */
+		Parameter /**< A parameter to be evaluated (pRetVal should be always set!) */
+	};
+
+	/**
+	* \enum RunFlags
+	*/
+	enum RunFlags {
+		PreserveParams = 1, /**< Do not delete the eventual parameters passed (only execute() and run()) */
+		// FIXME: This should be a global option, eventually
+		AssumeLocals = 2, /**< Assume that the variables are local unless explicitly declared (flag used only for parse()) */
+		// FIXME: This should be a global option, eventually
+		Pedantic = 4, /**< Be more pedantic: spit more warnings and sometimes more errors */
+		Quiet = 8 /**< Don't print any errors */
 	};
-protected:
-	// the name parameter is the name of the script context!
-	KviKvsScript(const QString &szName,const QString &szBuffer,KviKvsTreeNodeInstruction * pPreparsedTree,ScriptType eType = InstructionList);
 public:
-	// shallow copy of the script data
-	// useful when a script can be destroyed while running (like in timers)
-	KviKvsScript(const KviKvsScript &src);
-	KviKvsScript(const QString &szName,const QString &szBuffer,ScriptType eType=InstructionList);
+	/**
+	* \brief Constructs a KVIrc Script object
+	*
+	* This is a shallow copy of the script data useful when a script can
+	* be destroyed while running (like in timers)
+	* \param src The source script
+	* \return KviKvsScript
+	*/
+	KviKvsScript(const KviKvsScript & src);
+
+	/**
+	* \brief Constructs a KVIrc Script object
+	* \param szName The name of the context
+	* \param szBuffer The buffer :)
+	* \param eType The type of the code in the buffer
+	* \return KviKvsScript
+	*/
+	KviKvsScript(const QString & szName, const QString & szBuffer, ScriptType eType = InstructionList);
+
+	/**
+	* \brief Destroys a KVIrc Script object
+	*/
 	~KviKvsScript();
+protected:
+	/**
+	* \brief Constructs a KVIrc Script object
+	* \param szName The name of the context
+	* \param szBuffer The buffer :)
+	* \param pPreparsedTree The synthax tree
+	* \param eType The type of the code in the buffer
+	* \return KviKvsScript
+	*/
+	KviKvsScript(const QString & szName, const QString & szBuffer, KviKvsTreeNodeInstruction * pPreparsedTree, ScriptType eType = InstructionList);
 private:
 	KviKvsScriptData * m_pData;
 public:
+	/**
+	* \brief Returns the name of the script context
+	* \return const QString &
+	*/
 	const QString & name() const;
+
+	/**
+	* \brief Returns the code of the script
+	* \return const QString &
+	*/
 	const QString & code() const;
+
+	/**
+	* \brief Returns true if the script is locked, false otherwise
+	*
+	* The lock is set while the script is being executed
+	* \return bool
+	*/
 	bool locked() const;
 
-	void setName(const QString &szName);
+	/**
+	* \brief Sets the name of the script context
+	* \param szName The name of the context
+	* \return void
+	*/
+	void setName(const QString & szName);
 
-	enum RunFlags {
-		// do not delete the eventual parameters passed (only execute() and run())
-		PreserveParams = 1,
-		// assume that the variables are local unless explicitly declared (flag used only for parse())
-		AssumeLocals = 2, // FIXME: This should be a global option, eventually
-		// be more pedantic: spit more warnings and sometimes more errors
-		Pedantic = 4, // FIXME: This should be a global option, eventually
-		// don't print any errors
-		Quiet = 8
-	};
-	// returns 0 (KviKvsScript::RunFailure) on error
-	// returns a nonzero combination of RunStatus flags on success
-	int run(KviWindow * pWnd,                                // window that the command has to be bound to
-				KviKvsVariantList * pParams = 0,              // parameter list (0 if you don't pass params) ownership transferred if PreserverParams is not used
-				KviKvsVariant * pRetVal = 0,                  // return value buffer (0 if you ignore it)
-				int iRunFlags = 0,                            // a combination of run flags (usually default)
-				KviKvsExtendedRunTimeData * pExtData = 0);    // extended data (usually 0) (if you need to pass extended scope variables or alias switch lists...)
+	/**
+	* \brief Runs the script
+	*
+	* Returns 0 (KviKvsScript::RunFailure) on error
+	* Returns a nonzero combination of RunStatus flags on success
+	*
+	* If PreserverParams is not used, the ownership is transferred.
+	* Extended data is used if you need to pass extended scope variables or alias switch lists...)
+	* \param pWnd The window that the command has to be bound to
+	* \param pParams The parameter list (0 if you don't pass params)
+	* \param pRetVal Return value buffer (0 if you ignore it)
+	* \param iRunFlags A combination of run flags (usually default)
+	* \param pExtData Extended data (usually 0)
+	* \return int
+	*/
+	int run(KviWindow * pWnd, KviKvsVariantList * pParams = 0, KviKvsVariant * pRetVal = 0, int iRunFlags = 0, KviKvsExtendedRunTimeData * pExtData = 0);
+
+	/**
+	* \brief Runs the script
+	*
+	* Returns 0 (KviKvsScript::RunFailure) on error
+	* Returns a nonzero combination of RunStatus flags on success
+	*
+	* The QString return buffer is useful only for evaluating InstructionList scripts.
+	* If PreserverParams is not used, the ownership is transferred.
+	* Extended data is used if you need to pass extended scope variables or alias switch lists...)
+	* \param pWnd The window that the command has to be bound to
+	* \param pParams The parameter list (0 if you don't pass params)
+	* \param szRetVal Return value buffer
+	* \param iRunFlags A combination of run flags (usually default)
+	* \param pExtData Extended data (usually 0)
+	* \return int
+	*/
+	int run(KviWindow * pWnd, KviKvsVariantList * pParams, QString & szRetVal, int iRunFlags = 0, KviKvsExtendedRunTimeData * pExtData = 0);
 
-	// returns 0 (KviKvsScript::RunFailure) on error
-	// returns a nonzero combination of RunStatus flags on success
-	// this is probably used only in /eval
+	/**
+	* \brief Runs the script
+	*
+	* Returns 0 (KviKvsScript::RunFailure) on error
+	* Returns a nonzero combination of RunStatus flags on success
+	*
+	* This is probably used only in /eval
+	* \param pContext The context where the script is bound to
+	* \param iRunFlags A combination of run flags (usually default)
+	* \return int
+	*/
 	int run(KviKvsRunTimeContext * pContext,int iRunFlags = 0);
 
-	// same as run above, but gets a QString parameter as return buffer
-	// this is probably useful only for evaluating InstructionList scripts
-	int run(KviWindow * pWnd,
-				KviKvsVariantList * pParams,
-				QString &szRetVal,
-				int iRunFlags = 0,
-				KviKvsExtendedRunTimeData * pExtData = 0);
+	/**
+	* \brief Static helper for quick running
+	*
+	* Returns a combination of RunStatus flags (nonzero on no error)
+	* It does NOT take params ownership
+	* \param szCode The source code to run
+	* \param pWindow The window that the command has to be bound to
+	* \param pParams The parameter list (0 if you don't pass params)
+	* \param pRetVal Return value buffer (0 if you ignore it)
+	* \return int
+	*/
+	static int run(const QString & szCode, KviWindow * pWindow, KviKvsVariantList * pParams = 0, KviKvsVariant * pRetVal = 0);
 
-	// static helpers for quick running
-	// returns a combination of RunStatus flags (nonzero on no error)
-	// does NOT take params ownership
-	static int run(const QString &szCode,KviWindow * pWindow,KviKvsVariantList * pParams = 0,KviKvsVariant * pRetVal = 0);
+	/**
+	* \brief Static helper for quick evaluating parameters
+	*
+	* Returns a combination of RunStatus flags (nonzero on no error)
+	* It does NOT take params ownership.
+	* pRetVal CAN'T be zero here since we're evaluating stuff here
+	* \param szCode The source code to run
+	* \param pWindow The window that the command has to be bound to
+	* \param pParams The parameter list
+	* \param pRetVal Return value buffer
+	* \return int
+	*/
+	static int evaluate(const QString & szCode, KviWindow * pWindow, KviKvsVariantList * pParams, KviKvsVariant * pRetVal);
 
-	// static helper for quick evaluating parameters
-	// returns a combination of RunStatus flags (nonzero on no error)
-	// does NOT take params ownership
-	// pRetVal CAN'T be zero here since we're evaluating stuff here
-	static int evaluate(const QString &szCode,KviWindow * pWindow,KviKvsVariantList * pParams,KviKvsVariant * pRetVal);
-	static int evaluateAsString(const QString &szCode,KviWindow * pWindow,KviKvsVariantList * pParams,QString &szRetVal);
-public:
+	/**
+	* \brief Static helper for quick evaluating parameters
+	*
+	* Returns a combination of RunStatus flags (nonzero on no error)
+	* It does NOT take params ownership.
+	* The QString return buffer CAN'T be zero here since we're evaluating stuff here
+	* \param szCode The source code to run
+	* \param pWindow The window that the command has to be bound to
+	* \param pParams The parameter list
+	* \param szRetVal Return value buffer
+	* \return int
+	*/
+	static int evaluateAsString(const QString & szCode, KviWindow * pWindow, KviKvsVariantList * pParams, QString & szRetVal);
+
+	/**
+	* \brief Dumps the instructions tree
+	* \param prefix The prefix of the instruction
+	* \return void
+	*/
 	void dump(const char * prefix);
 protected:
-	// returns true after a succesfull parsing
-	// pOutput is useful only for printing errors
-	// if 0 , no errors are printed
-	bool parse(KviWindow * pOutput = 0,
-				int iRunFlags = 0);
-	// returns 0 (KviKvsScript::RunFailure) on error
-	// returns a nonzero combination of RunStatus flags on success
-	int execute(KviWindow * pWnd,
-				KviKvsVariantList * pParams = 0,
-				KviKvsVariant * pRetVal = 0,
-				int iRunFlags = 0,
-				KviKvsExtendedRunTimeData * pExtData = 0);
-	// returns 0 (KviKvsScript::RunFailure) on error
-	// returns a nonzero combination of RunStatus flags on success
+	/**
+	* \brief Returns true after a succesfull parsing, false otherwise
+	*
+	* pOutput is useful only for printing errors; if 0, no errors are printed
+	* \param pOutput The output window for errors
+	* \param iRunFlags A combination of run flags (usually default)
+	* \return bool
+	*/
+	bool parse(KviWindow * pOutput = 0, int iRunFlags = 0);
+
+	/**
+	* \brief Runs the script
+	*
+	* Returns 0 (KviKvsScript::RunFailure) on error
+	* Returns a nonzero combination of RunStatus flags on success
+	* \param pWnd The window that the command has to be bound to
+	* \param pParams The parameter list (0 if you don't pass params)
+	* \param pRetVal Return value buffer (0 if you ignore it)
+	* \param iRunFlags A combination of run flags (usually default)
+	* \param pExtData Extended data (usually 0)
+	* \return int
+	*/
+	int execute(KviWindow * pWnd, KviKvsVariantList * pParams = 0, KviKvsVariant * pRetVal = 0, int iRunFlags = 0, KviKvsExtendedRunTimeData * pExtData = 0);
+
+	/**
+	* \brief Runs the script
+	*
+	* Returns 0 (KviKvsScript::RunFailure) on error
+	* Returns a nonzero combination of RunStatus flags on success
+	* \param pContext The context where the script is bound to
+	* \return int
+	*/
 	int executeInternal(KviKvsRunTimeContext * pContext);
+
+	/**
+	* \brief Returns the data of the script
+	* \return const QChar *
+	*/
 	const QChar * buffer() const;
-	// detaches this script from any other shallow copies
+
+	/**
+	* \brief Detaches this script from any other shallow copies
+	* \return void
+	*/
 	void detach();
 };
 
+/**
+* \class KviKvsScriptData
+* \brief Holds the data of the script
+*/
+class KVIRC_API KviKvsScriptData
+{
+	friend class KviKvsScript;
+protected:
+	unsigned int                m_uRefs;     // Reference count for this structure
+
+	QString                     m_szName;    // script context name
+	QString                     m_szBuffer;  // NEVER TOUCH THIS
+	const QChar               * m_pBuffer;   // this points to m_szBuffer: use it to extract string data
+
+	KviKvsScript::ScriptType    m_eType;     // the type of the code in m_szBuffer
+
+	KviKvsTreeNodeInstruction * m_pTree;     // syntax tree
+	unsigned int                m_uLock;     // this is increased while the script is being executed
+};
 
-#endif //!_KVI_KVS_SCRIPT_H_
+#endif //_KVI_KVS_SCRIPT_H_
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_aliasfunctioncall.cpp b/src/kvirc/kvs/kvi_kvs_treenode_aliasfunctioncall.cpp
index ac31112a1..f779bfceb 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_aliasfunctioncall.cpp
+++ b/src/kvirc/kvs/kvi_kvs_treenode_aliasfunctioncall.cpp
@@ -28,35 +28,33 @@
 #include "kvi_locale.h"
 #include "kvi_qstring.h"
 
-KviKvsTreeNodeAliasFunctionCall::KviKvsTreeNodeAliasFunctionCall(const QChar * pLocation,const QString &szAliasName,KviKvsTreeNodeDataList * pParams)
+KviKvsTreeNodeAliasFunctionCall::KviKvsTreeNodeAliasFunctionCall(const QChar * pLocation, const QString & szAliasName, KviKvsTreeNodeDataList * pParams)
 : KviKvsTreeNodeFunctionCall(pLocation,szAliasName,pParams)
 {
-
 }
 
 KviKvsTreeNodeAliasFunctionCall::~KviKvsTreeNodeAliasFunctionCall()
 {
 }
 
-void KviKvsTreeNodeAliasFunctionCall::contextDescription(QString &szBuffer)
+void KviKvsTreeNodeAliasFunctionCall::contextDescription(QString & szBuffer)
 {
 	KviQString::sprintf(szBuffer,"Alias Function Call \"%Q\"",&m_szFunctionName);
 }
 
-
-
 void KviKvsTreeNodeAliasFunctionCall::dump(const char * prefix)
 {
 	qDebug("%s AliasFunctionCall(%s)",prefix,m_szFunctionName.toUtf8().data());
-	QString tmp = prefix;
-	tmp.append("  ");
-	m_pParams->dump(tmp.toUtf8().data());
+	QString szTmp = prefix;
+	szTmp.append("  ");
+	m_pParams->dump(szTmp.toUtf8().data());
 }
 
-bool KviKvsTreeNodeAliasFunctionCall::evaluateReadOnly(KviKvsRunTimeContext * c,KviKvsVariant * pBuffer)
+bool KviKvsTreeNodeAliasFunctionCall::evaluateReadOnly(KviKvsRunTimeContext * c, KviKvsVariant * pBuffer)
 {
 	KviKvsVariantList l;
-	if(!m_pParams->evaluate(c,&l))return false;
+	if(!m_pParams->evaluate(c,&l))
+		return false;
 	
 	pBuffer->setNothing();
 
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_aliasfunctioncall.h b/src/kvirc/kvs/kvi_kvs_treenode_aliasfunctioncall.h
index a63794085..4da26f319 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_aliasfunctioncall.h
+++ b/src/kvirc/kvs/kvi_kvs_treenode_aliasfunctioncall.h
@@ -24,6 +24,12 @@
 //
 //=============================================================================
 
+/**
+* \file kvi_kvs_treenode_aliasfunctioncall.h
+* \author Szymon Stefanek
+* \brief Treenode alias function call handling
+*/
+
 #include "kvi_settings.h"
 #include "kvi_qstring.h"
 #include "kvi_kvs_treenode_functioncall.h"
@@ -31,15 +37,48 @@
 
 class KviKvsRunTimeContext;
 
+/**
+* \class KviKvsTreeNodeAliasFunctionCall
+* \brief Treenode alias function call class
+*/
 class KVIRC_API KviKvsTreeNodeAliasFunctionCall : public KviKvsTreeNodeFunctionCall
 {
 public:
-	KviKvsTreeNodeAliasFunctionCall(const QChar * pLocation,const QString &szAliasName,KviKvsTreeNodeDataList * pParams);
+	/**
+	* \brief Constructs the treenode alias function call object
+	* \param pLocation The location char of the instruction
+	* \param szAliasName The name of the alias
+	* \param pParams The parameters' list
+	* \return KviKvsTreeNodeAliasFunctionCall
+	*/
+	KviKvsTreeNodeAliasFunctionCall(const QChar * pLocation, const QString & szAliasName, KviKvsTreeNodeDataList * pParams);
+
+	/**
+	* \brief Destroys the treenode alias function call object
+	*/
 	~KviKvsTreeNodeAliasFunctionCall();
 public:
+	/**
+	* \brief Dumps the tree
+	* \param prefix The prefix of the instruction
+	* \return void
+	*/
 	virtual void dump(const char * prefix);
-	virtual void contextDescription(QString &szBuffer);
-	virtual bool evaluateReadOnly(KviKvsRunTimeContext * c,KviKvsVariant * pBuffer);
+
+	/**
+	* \brief Sets the buffer as Alias Function Call
+	* \param szBuffer The buffer :)
+	* \return void
+	*/
+	virtual void contextDescription(QString & szBuffer);
+
+	/**
+	* \brief Evaluates the script in read-only mode
+	* \param c The context where the alias is bound to
+	* \param pBuffer The data buffer
+	* \return bool
+	*/
+	virtual bool evaluateReadOnly(KviKvsRunTimeContext * c, KviKvsVariant * pBuffer);
 };
 
-#endif //!_KVI_KVS_TREENODE_ALIASFUNCTIONCALL_H_
+#endif //_KVI_KVS_TREENODE_ALIASFUNCTIONCALL_H_
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_aliassimplecommand.cpp b/src/kvirc/kvs/kvi_kvs_treenode_aliassimplecommand.cpp
index 9bec5a1a0..712248d44 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_aliassimplecommand.cpp
+++ b/src/kvirc/kvs/kvi_kvs_treenode_aliassimplecommand.cpp
@@ -35,17 +35,16 @@
 #include "kvi_out.h"
 
 
-KviKvsTreeNodeAliasSimpleCommand::KviKvsTreeNodeAliasSimpleCommand(const QChar * pLocation,const QString &szCmdName,KviKvsTreeNodeDataList * params)
+KviKvsTreeNodeAliasSimpleCommand::KviKvsTreeNodeAliasSimpleCommand(const QChar * pLocation, const QString & szCmdName, KviKvsTreeNodeDataList * params)
 : KviKvsTreeNodeSimpleCommand(pLocation,szCmdName,params)
 {
 }
 
-
 KviKvsTreeNodeAliasSimpleCommand::~KviKvsTreeNodeAliasSimpleCommand()
 {
 }
 
-void KviKvsTreeNodeAliasSimpleCommand::contextDescription(QString &szBuffer)
+void KviKvsTreeNodeAliasSimpleCommand::contextDescription(QString & szBuffer)
 {
 	KviQString::sprintf(szBuffer,"Alias Simple Command \"%Q\"",&m_szCmdName);
 }
@@ -60,12 +59,14 @@ void KviKvsTreeNodeAliasSimpleCommand::dump(const char * prefix)
 bool KviKvsTreeNodeAliasSimpleCommand::execute(KviKvsRunTimeContext * c)
 {
 	KviKvsVariantList l;
-	if(!m_pParams->evaluate(c,&l))return false;
+	if(!m_pParams->evaluate(c,&l))
+		return false;
 
 	KviKvsSwitchList swl;
 	if(m_pSwitches)
 	{
-		if(!(m_pSwitches->evaluate(c,&swl)))return false;
+		if(!(m_pSwitches->evaluate(c,&swl)))
+			return false;
 	}
 
 	const KviKvsScript * s = KviKvsAliasManager::instance()->lookup(m_szCmdName);
@@ -76,7 +77,8 @@ bool KviKvsTreeNodeAliasSimpleCommand::execute(KviKvsRunTimeContext * c)
 			QString szAll;
 			l.allAsString(szAll);
 			
-			if(!szAll.isEmpty())szAll.prepend(" ");
+			if(!szAll.isEmpty())
+				szAll.prepend(" ");
 			szAll.prepend(m_szCmdName);
 
 			KviQCString szData;
@@ -87,7 +89,8 @@ bool KviKvsTreeNodeAliasSimpleCommand::execute(KviKvsRunTimeContext * c)
 				goto no_way_to_send_as_raw;
 
 			szData = c->window()->connection()->encodeText(szAll);
-			if(!szData.data())szData = "";
+			if(!szData.data())
+				szData = "";
 	
 			if(!c->window()->connection()->sendData(szData.data()))
 				goto no_way_to_send_as_raw;
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_aliassimplecommand.h b/src/kvirc/kvs/kvi_kvs_treenode_aliassimplecommand.h
index 69d1df447..ffd0b914b 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_aliassimplecommand.h
+++ b/src/kvirc/kvs/kvi_kvs_treenode_aliassimplecommand.h
@@ -24,6 +24,12 @@
 //
 //=============================================================================
 
+/**
+* \file kvi_kvs_treenode_aliassimplecommand.h
+* \author Szymon Stefanek
+* \brief Treenode alias simple command call handling
+*/
+
 #include "kvi_settings.h"
 #include "kvi_qstring.h"
 #include "kvi_kvs_treenode_simplecommand.h"
@@ -31,17 +37,47 @@
 class KviKvsTreeNodeDataList;
 class KviKvsRunTimeContext;
 
+/**
+* \class KviKvsTreeNodeAliasSimpleCommand
+* \brief Treenode alias simple command call class
+*/
 class KVIRC_API KviKvsTreeNodeAliasSimpleCommand : public KviKvsTreeNodeSimpleCommand
 {
 public:
-	KviKvsTreeNodeAliasSimpleCommand(const QChar * pLocation,const QString &szCmdName,KviKvsTreeNodeDataList * params);
+	/**
+	* \brief Constructs the treenode alias simple command call object
+	* \param pLocation The location char of the instruction
+	* \param szCmdName The name of the command
+	* \param pParams The parameters' list
+	* \return KviKvsTreeNodeAliasSimpleCommand
+	*/
+	KviKvsTreeNodeAliasSimpleCommand(const QChar * pLocation, const QString & szCmdName, KviKvsTreeNodeDataList * params);
+
+	/**
+	* \brief Destroys the treenode alias simple command call object
+	*/
 	~KviKvsTreeNodeAliasSimpleCommand();
 public:
-	virtual void contextDescription(QString &szBuffer);
+	/**
+	* \brief Sets the buffer as Alias Simple Command
+	* \param szBuffer The buffer :)
+	* \return void
+	*/
+	virtual void contextDescription(QString & szBuffer);
+
+	/**
+	* \brief Dumps the tree
+	* \param prefix The prefix of the instruction
+	* \return void
+	*/
 	virtual void dump(const char * prefix);
+
+	/**
+	* \brief Evaluates the command
+	* \param c The context where the command is bound to
+	* \return bool
+	*/
 	virtual bool execute(KviKvsRunTimeContext * c);
 };
 
-
-
-#endif //!_KVI_KVS_TREENODE_ALIASSIMPLECOMMAND_H_
+#endif //_KVI_KVS_TREENODE_ALIASSIMPLECOMMAND_H_
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_arraycount.cpp b/src/kvirc/kvs/kvi_kvs_treenode_arraycount.cpp
index a5de2254d..37b92abc3 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_arraycount.cpp
+++ b/src/kvirc/kvs/kvi_kvs_treenode_arraycount.cpp
@@ -29,7 +29,7 @@
 #include "kvi_kvs_object.h"
 
 
-KviKvsTreeNodeArrayCount::KviKvsTreeNodeArrayCount(const QChar * pLocation,KviKvsTreeNodeData * pSource)
+KviKvsTreeNodeArrayCount::KviKvsTreeNodeArrayCount(const QChar * pLocation, KviKvsTreeNodeData * pSource)
 : KviKvsTreeNodeIndirectData(pLocation,pSource)
 {
 }
@@ -38,7 +38,7 @@ KviKvsTreeNodeArrayCount::~KviKvsTreeNodeArrayCount()
 {
 }
 
-void KviKvsTreeNodeArrayCount::contextDescription(QString &szBuffer)
+void KviKvsTreeNodeArrayCount::contextDescription(QString & szBuffer)
 {
 	szBuffer = "Array Count Operator";
 }
@@ -48,14 +48,16 @@ void KviKvsTreeNodeArrayCount::dump(const char * prefix)
 	qDebug("%s ArrayCount",prefix);
 }
 
-bool KviKvsTreeNodeArrayCount::evaluateReadOnlyInObjectScope(KviKvsObject *o,KviKvsRunTimeContext * c,KviKvsVariant * pBuffer)
+bool KviKvsTreeNodeArrayCount::evaluateReadOnlyInObjectScope(KviKvsObject * o, KviKvsRunTimeContext * c, KviKvsVariant * pBuffer)
 {
 	KviKvsVariant val;
 	if(o)
 	{
-		if(!m_pSource->evaluateReadOnlyInObjectScope(o,c,&val))return false;
+		if(!m_pSource->evaluateReadOnlyInObjectScope(o,c,&val))
+			return false;
 	} else {
-		if(!m_pSource->evaluateReadOnly(c,&val))return false;
+		if(!m_pSource->evaluateReadOnly(c,&val))
+			return false;
 	}
 
 	if(!val.isArray())
@@ -74,7 +76,7 @@ bool KviKvsTreeNodeArrayCount::evaluateReadOnlyInObjectScope(KviKvsObject *o,Kvi
 	return true;
 }
 
-bool KviKvsTreeNodeArrayCount::evaluateReadOnly(KviKvsRunTimeContext * c,KviKvsVariant * pBuffer)
+bool KviKvsTreeNodeArrayCount::evaluateReadOnly(KviKvsRunTimeContext * c, KviKvsVariant * pBuffer)
 {
 	return evaluateReadOnlyInObjectScope(0,c,pBuffer);
 }
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_arraycount.h b/src/kvirc/kvs/kvi_kvs_treenode_arraycount.h
index 5b61057fa..8bd0341c0 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_arraycount.h
+++ b/src/kvirc/kvs/kvi_kvs_treenode_arraycount.h
@@ -24,6 +24,12 @@
 //
 //=============================================================================
 
+/**
+* \file kvi_kvs_treenode_arraycount.h
+* \author Szymon Stefanek
+* \brief Treenode array count handling
+*/
+
 #include "kvi_settings.h"
 #include "kvi_qstring.h"
 #include "kvi_kvs_treenode_indirectdata.h"
@@ -32,16 +38,56 @@ class KviKvsRunTimeContext;
 class KviKvsVariant;
 class KviKvsObject;
 
+/**
+* \class KviKvsTreeNodeArrayCount
+* \brief Treenode array count class
+*/
 class KVIRC_API KviKvsTreeNodeArrayCount : public KviKvsTreeNodeIndirectData
 {
 public:
-	KviKvsTreeNodeArrayCount(const QChar * pLocation,KviKvsTreeNodeData * pSource);
+	/**
+	* \brief Constructs the treenode array count object
+	* \param pLocation The location char of the instruction
+	* \param pSource The source data
+	* \return KviKvsTreeNodeArrayCount
+	*/
+	KviKvsTreeNodeArrayCount(const QChar * pLocation, KviKvsTreeNodeData * pSource);
+
+	/**
+	* \brief Destroys the treenode array count object
+	*/
 	~KviKvsTreeNodeArrayCount();
 public:
-	virtual void contextDescription(QString &szBuffer);
+	/**
+	* \brief Sets the buffer as Array Count Operator
+	* \param szBuffer The buffer :)
+	* \return void
+	*/
+	virtual void contextDescription(QString & szBuffer);
+
+	/**
+	* \brief Dumps the tree
+	* \param prefix The prefix of the instruction
+	* \return void
+	*/
 	virtual void dump(const char * prefix);
-	virtual bool evaluateReadOnly(KviKvsRunTimeContext * c,KviKvsVariant * pBuffer);
-	virtual bool evaluateReadOnlyInObjectScope(KviKvsObject *o,KviKvsRunTimeContext * c,KviKvsVariant * pBuffer);
+
+	/**
+	* \brief Evaluates the array in read-only mode
+	* \param c The context where the alias is bound to
+	* \param pBuffer The data buffer
+	* \return bool
+	*/
+	virtual bool evaluateReadOnly(KviKvsRunTimeContext * c, KviKvsVariant * pBuffer);
+
+	/**
+	* \brief Evaluates the array in read-only mode in the object scope
+	* \param o The source object to evaluate
+	* \param c The context where the array is bound to
+	* \param pBuffer The data buffer
+	* \return bool
+	*/
+	virtual bool evaluateReadOnlyInObjectScope(KviKvsObject * o, KviKvsRunTimeContext * c, KviKvsVariant * pBuffer);
 };
 
-#endif //!_KVI_KVS_TREENODE_ARRAYCOUNT_H_
+#endif //_KVI_KVS_TREENODE_ARRAYCOUNT_H_
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_arrayelement.cpp b/src/kvirc/kvs/kvi_kvs_treenode_arrayelement.cpp
index d4cbc9b1e..bf604a31a 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_arrayelement.cpp
+++ b/src/kvirc/kvs/kvi_kvs_treenode_arrayelement.cpp
@@ -28,20 +28,19 @@
 #include "kvi_kvs_array.h"
 #include "kvi_kvs_object.h"
 
-KviKvsTreeNodeArrayElement::KviKvsTreeNodeArrayElement(const QChar * pLocation,KviKvsTreeNodeData * pSource,KviKvsTreeNodeExpression * pIndex)
+KviKvsTreeNodeArrayElement::KviKvsTreeNodeArrayElement(const QChar * pLocation, KviKvsTreeNodeData * pSource, KviKvsTreeNodeExpression * pIndex)
 : KviKvsTreeNodeArrayOrHashElement(pLocation,pSource)
 {
 	m_pIndex = pIndex;
 	m_pIndex->setParent(this);
 }
 
-
 KviKvsTreeNodeArrayElement::~KviKvsTreeNodeArrayElement()
 {
 	delete m_pIndex;
 }
 
-void KviKvsTreeNodeArrayElement::contextDescription(QString &szBuffer)
+void KviKvsTreeNodeArrayElement::contextDescription(QString & szBuffer)
 {
 	szBuffer = "Array Element Evaluation";
 }
@@ -49,16 +48,17 @@ void KviKvsTreeNodeArrayElement::contextDescription(QString &szBuffer)
 void KviKvsTreeNodeArrayElement::dump(const char * prefix)
 {
 	debug("%s ArrayElement",prefix);
-	QString tmp = prefix;
-	tmp.append("  ");
-	m_pSource->dump(tmp.toUtf8().data());
-	m_pIndex->dump(tmp.toUtf8().data());
+	QString szTmp = prefix;
+	szTmp.append("  ");
+	m_pSource->dump(szTmp.toUtf8().data());
+	m_pIndex->dump(szTmp.toUtf8().data());
 }
 
-bool KviKvsTreeNodeArrayElement::evaluateIndex(KviKvsRunTimeContext *c,kvs_int_t &iVal)
+bool KviKvsTreeNodeArrayElement::evaluateIndex(KviKvsRunTimeContext * c, kvs_int_t & iVal)
 {
 	KviKvsVariant idx;
-	if(!m_pIndex->evaluateReadOnly(c,&idx))return false;
+	if(!m_pIndex->evaluateReadOnly(c,&idx))
+		return false;
 
 	if(!idx.asInteger(iVal))
 	{
@@ -74,18 +74,20 @@ bool KviKvsTreeNodeArrayElement::evaluateIndex(KviKvsRunTimeContext *c,kvs_int_t
 	return true;
 }
 
-
-bool KviKvsTreeNodeArrayElement::evaluateReadOnlyInObjectScope(KviKvsObject * o,KviKvsRunTimeContext * c,KviKvsVariant * pBuffer)
+bool KviKvsTreeNodeArrayElement::evaluateReadOnlyInObjectScope(KviKvsObject * o, KviKvsRunTimeContext * c, KviKvsVariant * pBuffer)
 {
 	kvs_int_t iVal;
-	if(!evaluateIndex(c,iVal))return false;
+	if(!evaluateIndex(c,iVal))
+		return false;
 
 	KviKvsVariant val;
 	if(o)
 	{
-		if(!m_pSource->evaluateReadOnlyInObjectScope(o,c,&val))return false;
+		if(!m_pSource->evaluateReadOnlyInObjectScope(o,c,&val))
+			return false;
 	} else {
-		if(!m_pSource->evaluateReadOnly(c,&val))return false;
+		if(!m_pSource->evaluateReadOnly(c,&val))
+			return false;
 	}
 
 	if(!val.isArray())
@@ -111,15 +113,19 @@ bool KviKvsTreeNodeArrayElement::evaluateReadOnlyInObjectScope(KviKvsObject * o,
 	return true;
 }
 
-KviKvsRWEvaluationResult * KviKvsTreeNodeArrayElement::evaluateReadWriteInObjectScope(KviKvsObject *o,KviKvsRunTimeContext * c)
+KviKvsRWEvaluationResult * KviKvsTreeNodeArrayElement::evaluateReadWriteInObjectScope(KviKvsObject * o, KviKvsRunTimeContext * c)
 {
 	kvs_int_t iVal;
-	if(!evaluateIndex(c,iVal))return false;
+	if(!evaluateIndex(c,iVal))
+		return false;
 
 	KviKvsRWEvaluationResult * result;
-	if(o)result = m_pSource->evaluateReadWriteInObjectScope(o,c);
+	if(o)
+		result = m_pSource->evaluateReadWriteInObjectScope(o,c);
 	else result = m_pSource->evaluateReadWrite(c);
-	if(!result)return 0;
+
+	if(!result)
+		return 0;
 
 	if(!result->result()->isArray())
 	{
@@ -135,7 +141,7 @@ KviKvsRWEvaluationResult * KviKvsTreeNodeArrayElement::evaluateReadWriteInObject
 	return new KviKvsArrayElement(result,result->result()->array()->getAt(iVal),result->result()->array(),iVal);
 }
 
-bool KviKvsTreeNodeArrayElement::evaluateReadOnly(KviKvsRunTimeContext * c,KviKvsVariant * pBuffer)
+bool KviKvsTreeNodeArrayElement::evaluateReadOnly(KviKvsRunTimeContext * c, KviKvsVariant * pBuffer)
 {
 	return evaluateReadOnlyInObjectScope(0,c,pBuffer);
 }
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_arrayelement.h b/src/kvirc/kvs/kvi_kvs_treenode_arrayelement.h
index 8b9824a29..63ec1af36 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_arrayelement.h
+++ b/src/kvirc/kvs/kvi_kvs_treenode_arrayelement.h
@@ -24,6 +24,12 @@
 //
 //=============================================================================
 
+/**
+* \file kvi_kvs_treenode_arrayelement.h
+* \author Szymon Stefanek
+* \brief Treenode array element handling
+*/
+
 #include "kvi_settings.h"
 #include "kvi_qstring.h"
 #include "kvi_kvs_treenode_expression.h"
@@ -33,22 +39,83 @@
 class KviKvsObject;
 class KviKvsRunTimeContext;
 
+/**
+* \class KviKvsTreeNodeArrayElement
+* \brief Treenode array element class
+*/
 class KVIRC_API KviKvsTreeNodeArrayElement : public KviKvsTreeNodeArrayOrHashElement
 {
 public:
-	KviKvsTreeNodeArrayElement(const QChar * pLocation,KviKvsTreeNodeData * pSource,KviKvsTreeNodeExpression * pIndex);
+	/**
+	* \brief Constructs the treenode array element object
+	* \param pLocation The location char of the instruction
+	* \param pSource The source data
+	* \param pIndex The index of the expression
+	* \return KviKvsTreeNodeArrayElement
+	*/
+	KviKvsTreeNodeArrayElement(const QChar * pLocation, KviKvsTreeNodeData * pSource, KviKvsTreeNodeExpression * pIndex);
+
+	/**
+	* \brief Destroys the treenode array element object
+	*/
 	~KviKvsTreeNodeArrayElement();
 protected:
 	KviKvsTreeNodeExpression * m_pIndex; // can't be null
 public:
-	virtual void contextDescription(QString &szBuffer);
+	/**
+	* \brief Sets the buffer as Array Element Evaluation
+	* \param szBuffer The buffer :)
+	* \return void
+	*/
+	virtual void contextDescription(QString & szBuffer);
+
+	/**
+	* \brief Dumps the tree
+	* \param prefix The prefix of the instruction
+	* \return void
+	*/
 	virtual void dump(const char * prefix);
-	virtual bool evaluateReadOnly(KviKvsRunTimeContext * c,KviKvsVariant * pBuffer);
+
+	/**
+	* \brief Evaluates the array element in read-only mode
+	* \param c The context where the alias is bound to
+	* \param pBuffer The data buffer
+	* \return bool
+	*/
+	virtual bool evaluateReadOnly(KviKvsRunTimeContext * c, KviKvsVariant * pBuffer);
+
+	/**
+	* \brief Evaluates the array element in read-write mode
+	* \param c The context where the alias is bound to
+	* \param pBuffer The data buffer
+	* \return KviKvsRWEvaluationResult *
+	*/
 	virtual KviKvsRWEvaluationResult * evaluateReadWrite(KviKvsRunTimeContext * c);
-	virtual bool evaluateReadOnlyInObjectScope(KviKvsObject *o,KviKvsRunTimeContext * c,KviKvsVariant * pBuffer);
-	virtual KviKvsRWEvaluationResult * evaluateReadWriteInObjectScope(KviKvsObject *o,KviKvsRunTimeContext * c);
+
+	/**
+	* \brief Evaluates the array element in read-only mode in the object scope
+	* \param o The source object to evaluate
+	* \param c The context where the array is bound to
+	* \param pBuffer The data buffer
+	* \return bool
+	*/
+	virtual bool evaluateReadOnlyInObjectScope(KviKvsObject * o, KviKvsRunTimeContext * c, KviKvsVariant * pBuffer);
+
+	/**
+	* \brief Evaluates the array element in read-write mode in the object scope
+	* \param o The source object to evaluate
+	* \param c The context where the array is bound to
+	* \return KviKvsRWEvaluationResult *
+	*/
+	virtual KviKvsRWEvaluationResult * evaluateReadWriteInObjectScope(KviKvsObject * o, KviKvsRunTimeContext * c);
 protected:
-	bool evaluateIndex(KviKvsRunTimeContext *c,kvs_int_t &iVal);
+	/**
+	* \brief Evaluates the index of the array
+	* \param c The context where the array is bound to
+	* \param iVal The index of the array
+	* \return bool
+	*/
+	bool evaluateIndex(KviKvsRunTimeContext * c, kvs_int_t & iVal);
 };
 
-#endif //!_KVI_KVS_TREENODE_ARRAYELEMENT_H_
+#endif //_KVI_KVS_TREENODE_ARRAYELEMENT_H_
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_arrayreferenceassert.cpp b/src/kvirc/kvs/kvi_kvs_treenode_arrayreferenceassert.cpp
index 4b1d29c88..fb6c7ec65 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_arrayreferenceassert.cpp
+++ b/src/kvirc/kvs/kvi_kvs_treenode_arrayreferenceassert.cpp
@@ -29,7 +29,7 @@
 #include "kvi_locale.h"
 #include "kvi_kvs_object.h"
 
-KviKvsTreeNodeArrayReferenceAssert::KviKvsTreeNodeArrayReferenceAssert(const QChar * pLocation,KviKvsTreeNodeData * pSource)
+KviKvsTreeNodeArrayReferenceAssert::KviKvsTreeNodeArrayReferenceAssert(const QChar * pLocation, KviKvsTreeNodeData * pSource)
 : KviKvsTreeNodeIndirectData(pLocation,pSource)
 {
 }
@@ -43,18 +43,17 @@ bool KviKvsTreeNodeArrayReferenceAssert::isReadOnly()
 	return m_pSource->isReadOnly();
 }
 
-void KviKvsTreeNodeArrayReferenceAssert::contextDescription(QString &szBuffer)
+void KviKvsTreeNodeArrayReferenceAssert::contextDescription(QString & szBuffer)
 {
 	szBuffer = "Array Reference Assert";
 }
 
-
 void KviKvsTreeNodeArrayReferenceAssert::dump(const char * prefix)
 {
 	qDebug("%s ArrayReferenceAssert",prefix);
 }
 
-bool KviKvsTreeNodeArrayReferenceAssert::evaluateReadOnlyInObjectScope(KviKvsObject *o,KviKvsRunTimeContext * c,KviKvsVariant * pBuffer)
+bool KviKvsTreeNodeArrayReferenceAssert::evaluateReadOnlyInObjectScope(KviKvsObject * o, KviKvsRunTimeContext * c, KviKvsVariant * pBuffer)
 {
 	if(o)
 	{
@@ -76,17 +75,20 @@ bool KviKvsTreeNodeArrayReferenceAssert::evaluateReadOnlyInObjectScope(KviKvsObj
 	return true;
 }
 
-KviKvsRWEvaluationResult * KviKvsTreeNodeArrayReferenceAssert::evaluateReadWriteInObjectScope(KviKvsObject *o,KviKvsRunTimeContext * c)
+KviKvsRWEvaluationResult * KviKvsTreeNodeArrayReferenceAssert::evaluateReadWriteInObjectScope(KviKvsObject * o, KviKvsRunTimeContext * c)
 {
 	KviKvsRWEvaluationResult * r;
-	if(o)r = m_pSource->evaluateReadWriteInObjectScope(o,c);
+	if(o)
+		r = m_pSource->evaluateReadWriteInObjectScope(o,c);
 	else r = m_pSource->evaluateReadWrite(c);
-	if(!r)return false;
+
+	if(!r)
+		return false;
 
 	return r;
 }
 
-bool KviKvsTreeNodeArrayReferenceAssert::evaluateReadOnly(KviKvsRunTimeContext * c,KviKvsVariant * pBuffer)
+bool KviKvsTreeNodeArrayReferenceAssert::evaluateReadOnly(KviKvsRunTimeContext * c, KviKvsVariant * pBuffer)
 {
 	return evaluateReadOnlyInObjectScope(0,c,pBuffer);
 }
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_arrayreferenceassert.h b/src/kvirc/kvs/kvi_kvs_treenode_arrayreferenceassert.h
index 93aeedaad..eb2b0eaec 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_arrayreferenceassert.h
+++ b/src/kvirc/kvs/kvi_kvs_treenode_arrayreferenceassert.h
@@ -24,6 +24,12 @@
 //
 //=============================================================================
 
+/**
+* \file kvi_kvs_treenode_arrayreferenceassert.h
+* \author Szymon Stefanek
+* \brief Treenode array reference assert handling
+*/
+
 #include "kvi_settings.h"
 #include "kvi_qstring.h"
 #include "kvi_kvs_treenode_indirectdata.h"
@@ -33,22 +39,81 @@ class KviKvsVariant;
 class KviKvsRWEvaluationResult;
 class KviKvsObject;
 
+/**
+* \class KviKvsTreeNodeArrayReferenceAssert
+* \brief Treenode array reference assert class
+*/
 class KVIRC_API KviKvsTreeNodeArrayReferenceAssert : public KviKvsTreeNodeIndirectData
 {
 public:
-	KviKvsTreeNodeArrayReferenceAssert(const QChar * pLocation,KviKvsTreeNodeData * pSource);
+	/**
+	* \brief Constructs the treenode array reference assert object
+	* \param pLocation The location char of the instruction
+	* \param pSource The source data
+	* \return KviKvsTreeNodeArrayReferenceAssert
+	*/
+	KviKvsTreeNodeArrayReferenceAssert(const QChar * pLocation, KviKvsTreeNodeData * pSource);
+
+	/**
+	* \brief Destroys the treenode array reference assert object
+	* \return KviKvsTreeNodeArrayElement
+	*/
 	~KviKvsTreeNodeArrayReferenceAssert();
 protected:
 
 public:
+	/**
+	* \brief Returns true if the array reference is read-only
+	* \return bool
+	*/
 	virtual bool isReadOnly();
-	virtual void contextDescription(QString &szBuffer);
+
+	/**
+	* \brief Sets the buffer as Array Reference Assert
+	* \param szBuffer The buffer :)
+	* \return void
+	*/
+	virtual void contextDescription(QString & szBuffer);
+
+	/**
+	* \brief Dumps the tree
+	* \param prefix The prefix of the instruction
+	* \return void
+	*/
 	virtual void dump(const char * prefix);
-	virtual bool evaluateReadOnly(KviKvsRunTimeContext * c,KviKvsVariant * pBuffer);
+
+	/**
+	* \brief Evaluates the array in read-only mode
+	* \param c The context where the alias is bound to
+	* \param pBuffer The data buffer
+	* \return bool
+	*/
+	virtual bool evaluateReadOnly(KviKvsRunTimeContext * c, KviKvsVariant * pBuffer);
+
+	/**
+	* \brief Evaluates the array in read-write mode
+	* \param c The context where the alias is bound to
+	* \param pBuffer The data buffer
+	* \return KviKvsRWEvaluationResult *
+	*/
 	virtual KviKvsRWEvaluationResult * evaluateReadWrite(KviKvsRunTimeContext * c);
-	virtual bool evaluateReadOnlyInObjectScope(KviKvsObject *o,KviKvsRunTimeContext * c,KviKvsVariant * pBuffer);
-	virtual KviKvsRWEvaluationResult * evaluateReadWriteInObjectScope(KviKvsObject *o,KviKvsRunTimeContext * c);
-};
 
+	/**
+	* \brief Evaluates the array in read-only mode in the object scope
+	* \param o The source object to evaluate
+	* \param c The context where the array is bound to
+	* \param pBuffer The data buffer
+	* \return bool
+	*/
+	virtual bool evaluateReadOnlyInObjectScope(KviKvsObject * o, KviKvsRunTimeContext * c, KviKvsVariant * pBuffer);
+
+	/**
+	* \brief Evaluates the array in read-write mode in the object scope
+	* \param o The source object to evaluate
+	* \param c The context where the array is bound to
+	* \return KviKvsRWEvaluationResult *
+	*/
+	virtual KviKvsRWEvaluationResult * evaluateReadWriteInObjectScope(KviKvsObject * o, KviKvsRunTimeContext * c);
+};
 
-#endif //!_KVI_KVS_TREENODE_ARRAYREFERENCEASSERT_H_
+#endif //_KVI_KVS_TREENODE_ARRAYREFERENCEASSERT_H_
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_base.cpp b/src/kvirc/kvs/kvi_kvs_treenode_base.cpp
index 093d79e66..81b27fbfb 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_base.cpp
+++ b/src/kvirc/kvs/kvi_kvs_treenode_base.cpp
@@ -23,7 +23,6 @@
 //=============================================================================
 
 
-
 #include "kvi_kvs_treenode_base.h"
 
 KviKvsTreeNode::KviKvsTreeNode(const QChar * pLocation)
@@ -31,5 +30,3 @@ KviKvsTreeNode::KviKvsTreeNode(const QChar * pLocation)
 	m_pParent = 0;
 	m_pLocation = pLocation;
 }
-
-
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_base.h b/src/kvirc/kvs/kvi_kvs_treenode_base.h
index fbb9f86d8..fd66e9ee4 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_base.h
+++ b/src/kvirc/kvs/kvi_kvs_treenode_base.h
@@ -24,28 +24,79 @@
 //
 //=============================================================================
 
+/**
+* \file kvi_kvs_treenode_base.h
+* \author Szymon Stefanek
+* \brief Treenode handling
+*/
+
 #include "kvi_settings.h"
 #include "kvi_qstring.h"
 
+/**
+* \class KviKvsTreeNode
+* \brief Treenode class
+*/
 class KVIRC_API KviKvsTreeNode
 {
 	friend class KviKvsParser;
 public:
+	/**
+	* \brief Constructs the treenode object
+	* \param pLocation The location char of the instruction
+	* \return KviKvsTreeNode
+	*/
 	KviKvsTreeNode(const QChar * pLocation);
+
+	/**
+	* \brief Destroys the treenode object
+	*/
 	virtual ~KviKvsTreeNode(){};
 protected:
 	KviKvsTreeNode * m_pParent;
 	const QChar    * m_pLocation;
 public:
+	/**
+	* \brief Sets the parent object
+	* \param p The parent treenode
+	* \return void
+	*/
 	void setParent(KviKvsTreeNode * p){ m_pParent = p; };
-protected:
-	// this is called only by KviKvsParser
-	void setLocation(const QChar * pLocation){ m_pLocation = pLocation; };
-public:
+
+	/**
+	* \brief Returns the parent object
+	* \return KviKvsTreeNode *
+	*/
 	KviKvsTreeNode * parent(){ return m_pParent; };
+
+	/**
+	* \brief Returns the location char
+	* \return const QChar *
+	*/
 	const QChar * location(){ return m_pLocation; };
+
+	/**
+	* \brief Dumps the tree
+	* \param prefix The prefix of the instruction
+	* \return void
+	*/
 	virtual void dump(const char * prefix) = 0;
-	virtual void contextDescription(QString &szBuffer) = 0;
+
+	/**
+	* \brief Sets the buffer
+	* \param szBuffer The buffer :)
+	* \return void
+	*/
+	virtual void contextDescription(QString & szBuffer) = 0;
+protected:
+	/**
+	* \brief Sets the location char
+	*
+	* This is called only by KviKvsParser
+	* \param pLocation The location char
+	* \return void
+	*/
+	void setLocation(const QChar * pLocation){ m_pLocation = pLocation; };
 };
 
-#endif //!_KVI_KVS_TREENODE_BASE_H_
+#endif //_KVI_KVS_TREENODE_BASE_H_
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_instruction.cpp b/src/kvirc/kvs/kvi_kvs_treenode_instruction.cpp
index 4278172ab..09e3ac47a 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_instruction.cpp
+++ b/src/kvirc/kvs/kvi_kvs_treenode_instruction.cpp
@@ -23,10 +23,9 @@
 //=============================================================================
 
 
-
 #include "kvi_kvs_treenode_instruction.h"
 
-void KviKvsTreeNodeInstruction::contextDescription(QString &szBuffer)
+void KviKvsTreeNodeInstruction::contextDescription(QString & szBuffer)
 {
 	szBuffer = "Instruction";
 }
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_instruction.h b/src/kvirc/kvs/kvi_kvs_treenode_instruction.h
index b930fcd9e..0df8c7533 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_instruction.h
+++ b/src/kvirc/kvs/kvi_kvs_treenode_instruction.h
@@ -2,7 +2,7 @@
 #define _KVI_KVS_TREENODE_INSTRUCTION_H_
 //=============================================================================
 //
-//   File : kvi_kvs_treenode.h
+//   File : kvi_kvs_treenode_instruction.h
 //   Creation date : Mon 06 Oct 2003 03.46 CEST by Szymon Stefanek
 //
 //   This file is part of the KVirc irc client distribution
@@ -24,31 +24,62 @@
 //
 //=============================================================================
 
+/**
+* \file kvi_kvs_treenode.h
+* \author Szymon Stefanek
+* \brief Treenode instruction handling
+*/
+
 #include "kvi_qstring.h"
 #include "kvi_kvs_treenode_base.h"
 
 class KviKvsRunTimeContext;
 
-
+/**
+* \class KviKvsTreeNodeInstruction
+* \brief Treenode class to handle instructions
+*/
 class KVIRC_API KviKvsTreeNodeInstruction : public KviKvsTreeNode
 {
 public:
+	/**
+	* \brief Constructs the treenode instruction object
+	* \param pLocation The location char of the instruction
+	* \return KviKvsTreeNodeInstruction
+	*/
 	KviKvsTreeNodeInstruction(const QChar * pLocation)
 	: KviKvsTreeNode(pLocation){};
+
+	/**
+	* \brief Destroys the treenode instruction object
+	*/
 	~KviKvsTreeNodeInstruction(){};
 public:
-	virtual void contextDescription(QString &szBuffer);
+	/**
+	* \brief Sets the buffer as Instruction
+	* \param szBuffer The buffer :)
+	* \return void
+	*/
+	virtual void contextDescription(QString & szBuffer);
+
+	/**
+	* \brief Dumps the instructions tree
+	* \param prefix The prefix of the instruction
+	* \return void
+	*/
 	virtual void dump(const char * prefix);
 	
-	// execute() is the main entry point to the tree visit
-	// execute() returns false when the tree visiting has
-	// to be stopped and returns true when it has been
-	// succesfully completed. A false return value may
-	// signal an error but is also used by break, halt, return
-	// and similar. The error condition is signaled by
-	// KviKvsRunTimeContext::error().
+	/**
+	* \brief This is the main entry point to the tree visit
+	*
+	* It returns false when the tree visiting has to be stopped and returns
+	* true when it has been succesfully completed. A false return value may
+	* signal an error but is also used by break, halt, return and similar.
+	* The error condition is signaled by KviKvsRunTimeContext::error().
+	* \param c The source context
+	* \return bool
+	*/
 	virtual bool execute(KviKvsRunTimeContext * c) = 0;
 };
 
-
-#endif //!_KVI_KVS_TREENODE_H_
+#endif //_KVI_KVS_TREENODE_H_
diff --git a/src/modules/aliaseditor/aliaseditor.cpp b/src/modules/aliaseditor/aliaseditor.cpp
index 61e6215ef..ade4b7b28 100644
--- a/src/modules/aliaseditor/aliaseditor.cpp
+++ b/src/modules/aliaseditor/aliaseditor.cpp
@@ -482,9 +482,9 @@ bool KviAliasEditor::itemExists(QTreeWidgetItem *pSearchFor)
 
 	for (int i=0;i<m_pTreeWidget->topLevelItemCount();i++)
 	{
-			if(m_pTreeWidget->topLevelItem(i)==pSearchFor) return true;
-		else
-		{
+		if(m_pTreeWidget->topLevelItem(i)==pSearchFor)
+			return true;
+		else {
 			if(!((KviAliasEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i))->isAlias())
 			{
 				if (itemExistsRecursive(pSearchFor,m_pTreeWidget->topLevelItem(i))) return true;
@@ -625,12 +625,10 @@ void KviAliasEditor::slotFind()
 			if(((KviAliasTreeWidgetItem *)m_pTreeWidget->topLevelItem(i))->buffer().indexOf(szSearch,0,Qt::CaseInsensitive) != -1)
 			{
 				m_pTreeWidget->topLevelItem(i)->setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_ALIASHIGHLIGHTED))));
-			}
-			else 
+			} else {
 				m_pTreeWidget->topLevelItem(i)->setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_ALIAS))));
-		
-		}
-		else {
+			}
+		} else {
 			recursiveSearchReplace(szSearch,(KviAliasEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i));
 		}
 	}
diff --git a/src/modules/channelsjoin/channelsjoinwindow.cpp b/src/modules/channelsjoin/channelsjoinwindow.cpp
index 188d9db4e..7670f63f5 100644
--- a/src/modules/channelsjoin/channelsjoinwindow.cpp
+++ b/src/modules/channelsjoin/channelsjoinwindow.cpp
@@ -34,7 +34,7 @@
 #include "kvi_regchan.h"
 #include "kvi_kvs_script.h"
 #include "kvi_tal_treewidget.h"
-#include <kvi_tal_groupbox.h>
+#include "kvi_tal_groupbox.h"
 
 #include <QLabel>
 #include <QLineEdit>
@@ -43,6 +43,7 @@
 #include <QEvent>
 #include <QCloseEvent>
 #include <QHeaderView>
+#include <QCheckBox>
 
 
 extern KviChannelsJoinWindow * g_pChannelsWindow;
@@ -51,25 +52,25 @@ extern QRect                   g_rectChannelsJoinGeometry;
 extern KVIRC_API KviRegisteredChannelDataBase * g_pRegisteredChannelDataBase;
 
 
-KviChannelsJoinWindow::KviChannelsJoinWindow(QWidget * par, const char * name) 
+KviChannelsJoinWindow::KviChannelsJoinWindow(QWidget * par, const char * name)
 : QDialog(par)
 {
 	setObjectName(name);
-	m_pConsole=0;
 	setWindowTitle(__tr2qs("Join Channels"));
-
 	setWindowIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_CHANNEL)));
 
+	m_pConsole = 0;
+
 	QGridLayout * g = new QGridLayout(this);
 	
-	m_pListView = new KviTalTreeWidget(this);
-	m_pListView->addColumn(__tr2qs("Channel"));
-	m_pListView->setRootIsDecorated(true);
-	m_pListView->setSelectionMode(QAbstractItemView::SingleSelection);
-	g->addWidget(m_pListView,0,0,1,2);
-	//g->addMultiCellWidget(m_pListView,0,0,0,1);
-	connect(m_pListView,SIGNAL(itemClicked(QTreeWidgetItem *,int)),this,SLOT(itemClicked(QTreeWidgetItem *,int)));
-	connect(m_pListView,SIGNAL(itemActivated(QTreeWidgetItem *,int)),this,SLOT(itemDoubleClicked(QTreeWidgetItem *,int)));
+	m_pTreeWidget = new KviTalTreeWidget(this);
+	m_pTreeWidget->addColumn(__tr2qs("Channel"));
+	m_pTreeWidget->setRootIsDecorated(true);
+	m_pTreeWidget->setSelectionMode(QAbstractItemView::SingleSelection);
+	g->addWidget(m_pTreeWidget,0,0,1,2);
+	//g->addMultiCellWidget(m_pTreeWidget,0,0,0,1);
+	connect(m_pTreeWidget,SIGNAL(itemClicked(QTreeWidgetItem *,int)),this,SLOT(itemClicked(QTreeWidgetItem *,int)));
+	connect(m_pTreeWidget,SIGNAL(itemActivated(QTreeWidgetItem *,int)),this,SLOT(itemDoubleClicked(QTreeWidgetItem *,int)));
 
 
 	m_pGroupBox = new KviTalGroupBox(Qt::Horizontal,__tr2qs("Channel" ),this);
@@ -89,7 +90,7 @@ KviChannelsJoinWindow::KviChannelsJoinWindow(QWidget * par, const char * name)
 	m_pPass->setEchoMode(QLineEdit::Password);
 
 	g->addWidget(m_pGroupBox,1,0,1,2);
-//	g->addMultiCellWidget(m_pGroupBox,1,1,0,1);
+	//g->addMultiCellWidget(m_pGroupBox,1,1,0,1);
 
 	KviTalHBox * hb = new KviTalHBox(this);
 	hb->setSpacing(4);
@@ -150,24 +151,23 @@ KviChannelsJoinWindow::~KviChannelsJoinWindow()
 
 void KviChannelsJoinWindow::setConsole(KviConsole  * pConsole)
 {
-	m_pConsole=pConsole;
+	m_pConsole = pConsole;
 	fillListView();
 }
 
 void KviChannelsJoinWindow::fillListView()
 {
-	m_pListView->clear();
+	m_pTreeWidget->clear();
 
-	m_pListView->header()->hide();
+	m_pTreeWidget->header()->hide();
 
-	KviTalTreeWidgetItem * par = new KviTalTreeWidgetItem(m_pListView,__tr2qs("Recent Channels"));
+	KviTalTreeWidgetItem * par = new KviTalTreeWidgetItem(m_pTreeWidget,__tr2qs("Recent Channels"));
 	par->setExpanded(true);
 	KviTalTreeWidgetItem * chld;
 	
 	if(m_pConsole)
 	{
-	
-		QStringList* pList=g_pApp->getRecentChannels(m_pConsole->currentNetworkName());
+		QStringList * pList = g_pApp->getRecentChannels(m_pConsole->currentNetworkName());
 		if(pList)
 		{
 			for(QStringList::Iterator it = pList->begin(); it != pList->end(); ++it)
@@ -178,7 +178,7 @@ void KviChannelsJoinWindow::fillListView()
 		}
 	}
 
-	par = new KviTalTreeWidgetItem(m_pListView,__tr2qs("Registered Channels"));
+	par = new KviTalTreeWidgetItem(m_pTreeWidget,__tr2qs("Registered Channels"));
 	par->setExpanded(true);
 
 	KviPointerHashTable<const char *,KviRegisteredChannelList> * d = g_pRegisteredChannelDataBase->channelDict();
@@ -194,21 +194,27 @@ void KviChannelsJoinWindow::fillListView()
 	}
 }
 
-void KviChannelsJoinWindow::itemClicked(QTreeWidgetItem * it,int) 
+void KviChannelsJoinWindow::itemClicked(QTreeWidgetItem * it)
 {
-	if(!it)return;
-	if(!it->parent())return;
-	QString tmp = it->text(0);
-	m_pChannelEdit->setText(tmp);
+	if(!it)
+		return;
+	if(!it->parent())
+		return;
+
+	QString szTmp = it->text(0);
+	m_pChannelEdit->setText(szTmp);
 	enableJoin();
 }
 
-void KviChannelsJoinWindow::itemDoubleClicked(QTreeWidgetItem * it,int) 
+void KviChannelsJoinWindow::itemDoubleClicked(QTreeWidgetItem * it)
 {
-	if(!it)return;
-	if(!it->parent())return;
-	KviStr tmp = it->text(0);
-	m_pChannelEdit->setText(tmp.ptr());
+	if(!it)
+		return;
+	if(!it->parent())
+		return;
+
+	QString szTmp = it->text(0);
+	m_pChannelEdit->setText(szTmp);
 	enableJoin();
 	joinClicked();
 }
@@ -220,11 +226,11 @@ void KviChannelsJoinWindow::editTextChanged(const QString &)
 
 void KviChannelsJoinWindow::enableJoin()
 {
-	KviStr tmp = m_pChannelEdit->text();
+	QString szTmp = m_pChannelEdit->text();
 	KviConsole * c = g_pApp->topmostConnectedConsole();
 	if(c)
 	{
-		if(tmp.isEmpty())
+		if(szTmp.isEmpty())
 		{
 			m_pJoinButton->setEnabled(false);
 			m_pRegButton->setEnabled(false);
@@ -233,7 +239,7 @@ void KviChannelsJoinWindow::enableJoin()
 			m_pRegButton->setEnabled(true);
 		}
 	} else {
-		m_pListView->setEnabled(false);
+		m_pTreeWidget->setEnabled(false);
 		m_pGroupBox->setEnabled(false);
 		m_pJoinButton->setEnabled(false);
 	}
@@ -246,18 +252,26 @@ void KviChannelsJoinWindow::cancelClicked()
 
 void KviChannelsJoinWindow::joinClicked()
 {
-	KviStr pass = m_pPass->text();
-	KviStr tmp = m_pChannelEdit->text();
+	QString szPass = m_pPass->text();
+	QString szTmp = m_pChannelEdit->text();
 
-	if(tmp.isEmpty())return;
+	if(szTmp.isEmpty())
+		return;
 
-	KviStr command(KviStr::Format,"join %s %s",tmp.ptr(),pass.ptr());
+	QString szCmd = "join ";
+	szCmd += szTmp;
+	szCmd += " ";
+	szCmd += szPass;
 
 	KviConsole * c = g_pApp->topmostConnectedConsole();
-	if(!c)return; // no connection
+	if(!c)
+		return; // no connection
+
 	KviWindow * w = g_pActiveWindow;
-	if(w->console() != c)w = c;
-	KviKvsScript::run(command.ptr(),w);
+	if(w->console() != c)
+		w = c;
+
+	KviKvsScript::run(szCmd,w);
 
 	m_pChannelEdit->setText("");
 	m_pPass->setText("");
@@ -265,18 +279,23 @@ void KviChannelsJoinWindow::joinClicked()
 
 void KviChannelsJoinWindow::regClicked()
 {
-	KviStr tmp = m_pChannelEdit->text();
-	QList<QModelIndex> index;
+	QString szTmp = m_pChannelEdit->text();
 
-	if(tmp.isEmpty())return;
+	if(szTmp.isEmpty())
+		return;
 
-	KviStr command(KviStr::Format,"regchan.add %s",tmp.ptr());
+	QString szCmd = "regchan.add ";
+	szCmd += szTmp;
 
 	KviConsole * c = g_pApp->topmostConnectedConsole();
-	if(!c)return; // no connection
+	if(!c)
+		return; // no connection
+
 	KviWindow * w = g_pActiveWindow;
-	if(w->console() != c)w = c;
-	KviKvsScript::run(command.ptr(),w);
+	if(w->console() != c)
+		w = c;
+
+	KviKvsScript::run(szCmd,w);
 	fillListView();
 }
 
@@ -309,7 +328,7 @@ void KviChannelsJoinWindow::editReturnPressed()
 	joinClicked();
 }
 
-void KviChannelsJoinWindow::closeEvent(QCloseEvent *e)
+void KviChannelsJoinWindow::closeEvent(QCloseEvent * e)
 {
 	e->ignore();
 	delete this;
@@ -317,4 +336,4 @@ void KviChannelsJoinWindow::closeEvent(QCloseEvent *e)
 
 #ifndef COMPILE_USE_STANDALONE_MOC_SOURCES
 #include "m_channelsjoinwindow.moc"
-#endif //!COMPILE_USE_STANDALONE_MOC_SOURCES
+#endif //COMPILE_USE_STANDALONE_MOC_SOURCES
diff --git a/src/modules/channelsjoin/channelsjoinwindow.h b/src/modules/channelsjoin/channelsjoinwindow.h
index df3c7e896..f0677a6ff 100644
--- a/src/modules/channelsjoin/channelsjoinwindow.h
+++ b/src/modules/channelsjoin/channelsjoinwindow.h
@@ -1,7 +1,9 @@
+#ifndef _CHANNELSJOIN_H_
+#define _CHANNELSJOIN_H_
 //=============================================================================
 //
 //   File : channelsjoinwindow.h
-//   Creation date : Thu Nov 06 2001 12:30:25 CEST by Juan Jos��varez
+//   Creation date : Thu Nov 06 2001 12:30:25 CEST by Juan Alvarez
 //
 //   This file is part of the KVirc irc client distribution
 //   Copyright (C) 2001-2008 Szymon Stefanek (pragma at kvirc dot net)
@@ -22,52 +24,130 @@
 //
 //=============================================================================
 
-#ifndef _CHANNELSJOIN_H_
-#define _CHANNELSJOIN_H_
+/**
+* \file channelsjoinwindow.h
+* \author Juan Alvarez
+* \brief Channels join window
+*/
+
 #include "kvi_window.h"
 #include "kvi_string.h"
 #include "kvi_tal_treewidget.h"
 
-#include <QCheckBox>
 #include <QDialog>
 
+class QCheckBox;
 class QPushButton;
 class QLineEdit;
 class KviConsole;
 class KviTalGroupBox;
 
-
+/**
+* \class KviChannelsJoinWindow
+* \brief Channels join window class
+*/
 class KviChannelsJoinWindow : public QDialog
 {
 	Q_OBJECT
 public:
+	/**
+	* \brief Constructs the channels join window
+	* \param par The parent widget
+	* \param name The name of the window
+	* \return KviChannelsJoinWindow
+	*/
 	KviChannelsJoinWindow(QWidget * par, const char * name);
+
+	/**
+	* \brief Destroys the channels join window
+	*/
 	~KviChannelsJoinWindow();
 protected:
-	QLineEdit   * m_pChannelEdit; 
-	KviTalTreeWidget   * m_pListView;
+	QLineEdit        * m_pChannelEdit;
+	KviTalTreeWidget * m_pTreeWidget;
 	KviTalGroupBox   * m_pGroupBox;
-	QLineEdit   * m_pPass;
-	QCheckBox   * m_pShowAtStartupCheck;
-	QCheckBox   * m_pCloseAfterJoinCheck;
-	QPushButton * m_pJoinButton;
-	QPushButton * m_pRegButton;
-	KviConsole  * m_pConsole;
+	QLineEdit        * m_pPass;
+	QCheckBox        * m_pShowAtStartupCheck;
+	QCheckBox        * m_pCloseAfterJoinCheck;
+	QPushButton      * m_pJoinButton;
+	QPushButton      * m_pRegButton;
+	KviConsole       * m_pConsole;
 public:
-	virtual void closeEvent(QCloseEvent *e);
+	virtual void closeEvent(QCloseEvent * e);
+
+	/**
+	* \brief Fills in the servers' list
+	* \return void
+	*/
 	void fillListView();
+
+	/**
+	* \brief Enables join and register button if channel is found
+	* \return void
+	*/
 	void enableJoin();
-	void setConsole(KviConsole  * pConsole);
+
+	/**
+	* \brief Sets the console and fills in the servers' list
+	* \param pConsole The source console
+	* \return void
+	*/
+	void setConsole(KviConsole * pConsole);
 protected slots:
+	/**
+	* \brief Called when the text changes
+	* \return void
+	*/
 	void editTextChanged(const QString &);
-	void itemClicked(QTreeWidgetItem *it,int);
-	void itemDoubleClicked(QTreeWidgetItem *it,int);
+
+	/**
+	* \brief Called when an item is clicked
+	* \param it The item clicked
+	* \return void
+	*/
+	void itemClicked(QTreeWidgetItem * it);
+
+	/**
+	* \brief Called when an item is double-clicked
+	* \param it The item clicked
+	* \return void
+	*/
+	void itemDoubleClicked(QTreeWidgetItem * it);
+
+	/**
+	* \brief Called when the return is pressed
+	*
+	* It joins the selected channel
+	* \return void
+	*/
 	void editReturnPressed();
+
+	/**
+	* \brief Called when the cancel button is pressed
+	*
+	* It destroys the window object
+	* \return void
+	*/
 	void cancelClicked();
+
+	/**
+	* \brief Called when the join button is pressed
+	*
+	* It joins the selected channel
+	* \return void
+	*/
 	void joinClicked();
+
+	/**
+	* \brief Called when the register button is pressed
+	*
+	* It registers the selected channel in the database
+	* \return void
+	*/
 	void regClicked();
-//	void whoClicked();
-//	void namesClicked();
+
+	//void whoClicked();
+	//void namesClicked();
 };
 
 #endif //_CHANNELSJOINSWINDOW_H_