Kvi(Various).cpp Capitalization punctuation, typos fixes

3 files changed, 55 insertions, 55 deletions

diff --git a/src/kvilib/ext/KviCryptEngine.cpp b/src/kvilib/ext/KviCryptEngine.cpp
index 6ec745cbd..fcc9c63ae 100644
--- a/src/kvilib/ext/KviCryptEngine.cpp
+++ b/src/kvilib/ext/KviCryptEngine.cpp
@@ -36,7 +36,7 @@
 	@type:
 		generic
 	@keyterms:
-		cryptography, privacy, private key, text transformation
+		cryptography, encryption, privacy, private key, text transformation
 	@title:
 		Cryptography and text transformation
 	@short:
@@ -45,62 +45,62 @@
 		[big]Introduction[/big][br]
 		Well, there is a concrete background noise about security around the net.
 		And I've thought that adding a little cryptography support to KVIrc wasn't
-		a bad idea. So I've first comed out with the "crypt engines", that
-		allowed to have secure conversations on channels, queries and dcc chats;
+		a bad idea. So I first came up with the "crypt engines", that
+		allowed secure conversations in channels, queries and DCC chats;
 		then found out that the realized structure was perfect to be "generalized"
 		into "text transformation" support.[br]
 		[big]The concept[/big][br]
 		In few words, the "text transformation" engine is a layer between the user and the
 		IRC connection. You type some text in the input line of a query window (for example),
 		the engine transforms the text in some way and then sends it to the remote target.
-		The trick works also in the reverse way: some data come from the remote target,
-		the engine retransforms the text in some other way and displays it to the local user.[br]
+		The trick works also in the reverse way: some data comes from the remote target,
+		the engine re-transforms the text in some other way and displays it to the local user.[br]
 		The "incoming" transformation is usually the inverse of the "outgoing" one, but it
 		is not mandatory. It will become clear in few sentences that some engines will do no "incoming"
-		transformation at all. The original use of the transformation engines was to crypt the
+		transformation at all. The original use of the transformation engines was to encrypt the
 		outgoing data and to decrypt the incoming data; anyway, the engines can perform
-		other funky tasks. One of them is remapping the local charset to a "standardized" one
+		other funky tasks. One of them is remapping the local charset to a standardized one
 		when sending text to a channel (or some other target) and doing the inverse map on
 		the way back. A totally "fantastic" usage of this concept could be an "on-the-fly translator";
 		it could translate for example Italian to English while sending to a channel
-		and English to Italian on the way back...the implementation of a such engine is left
+		and English to Italian on the way back... the implementation of a such engine is left
 		to the reader as exercise :) Another (maybe less interesting) usage is to
 		colorize the outgoing text, or transform it
 		in a way that it is still readable but has a different look. This engine
 		would not require a back transformation (so no "decrypt stage"). A "symmetric"
 		idea could be an engine that strips the color codes from the incoming text: this
-		engine would not require a "crypting" stage.[br]
+		engine would not require an encrypting stage.[br]
 
-		[big]The name of this stuf[/big][br]
-		Initially all this stuff was named "cryptography support".
-		Then the "cryptography" comed out to be not "enough" to describe
+		[big]The name of this stuff[/big][br]
+		Initially all this was named "cryptography support".
+		Then "cryptography" was no longer enough to describe
 		the framework, so "text transformation" is a more generic term.
 		Anyway, both terms were used in the documentation and the source.
 		Just as example, the "text transformation engine" is called
 		KviCryptEngine in the sources. So actually the terms "crypt"
-		and "text transformations" refer to the "same thing".
+		and text transformation refer to the same thing.
 		You will often find the term "encrypt" standing for "outgoing text
 		transformation" and "decrypt" standing for "incoming text transformation".[br]
 
-		[big]Yes, but why cryptography (on IRC) ?[/big][br]
+		[big]Yes, but why cryptography (on IRC)?[/big][br]
 		Because it MAY be useful. More than once people have asked me to add some
-		crypting support to the dcc chats. Yes, I know that there are other
+		encryption support to the DCC chats. Yes, I know that there are other
 		"secure communication" tools, but actually I can't find one that is able to
 		implement a "secure real time conversation". And what about a MULTIPLE real
-		time secure conversation ? This can be done on an IRC channel now.[br]
+		time secure conversation? This can be done on an IRC channel now.[br]
 
 		[big]The working things[/big][br]
-		KVIrc can use a text transformation engine on irc channels, in the queries
-		and the dcc chats. At the time I am writing, only the [module:rijndael]Rijndael[/module] crypt engine
+		KVIrc can use a text transformation engine on IRC channels, in the queries
+		and the DCC chats. At the time I am writing, only the [module:rijndael]Rijndael[/module] crypt engine
 		is available: this is a private key encryption algorithm that assures
 		a "pretty good" security level. More engines will be surely available
 		at the time of the 3.0.0 release of KVIrc. The engines
 		can be activated by the dedicated dialog that can be accessed from the "button bar"
 		of the window. Once an engine has been enabled all the text that you type
 		in the input line (that is not a command obviously) is encrypted
-		and sent to the remote endpoint. If you want to sent a non crypted message
-		while an engine is working you can use the CTRL+P escape: by placing
-		that character as the FIRST CHARACTER of the line you will avoid crypting.
+		and sent to the remote endpoint. If you want to send a non-encrypted message
+		while an engine is working, you can use the CTRL+P escape: by placing
+		that character as the FIRST CHARACTER of the line you will avoid encrypting.
 		Every engine has different capabilities: some can both encrypt
 		and decrypt, other perform only half of the operations. Some engines
 		need a key (the crypt engines obviously), or two keys (you can specify
@@ -109,13 +109,13 @@
 		Obviously (with the current implementations) all the conversation endpoints
 		must agree on the engine (or better algorithm) used and on the key(s).
 		The key is user specified, so you have to find a secure way to negotiate
-		it with your communication engpoints. If you can meet the persons in the "real life",
-		this is the best way to exchange the keys, otherwise you can use mail & pgp.
-		Yes, this is a "miss" of the crypt protocol: it is missing a public key handshake.[br]
+		it with your communication endpoints. If you can meet these people in real life,
+		this is the best way to exchange the keys, otherwise you can use mail & PGP.
+		Yes, this is a shortcoming of the crypt protocol: it is missing a public key handshake.[br]
 
 		[big]The first test[/big][br]
-		A cool way to test a crypting engine is to use a "self query": connect to
-		any irc server, and execute [cmd]query[/cmd] <yournickname>; a query window
+		A cool way to test an encryption engine is to use a "self query": connect to
+		any IRC server, and execute [cmd]query[/cmd] <yournickname>; a query window
 		with you both as source and target will popup; activate a crypt engine
 		and enable both encryption and decryption; specify the same key for
 		bot directions and then type some text in the input line: you will see
@@ -128,25 +128,25 @@
 		[big]The protocol[/big][br]
 		Well, there is no protocol actually, only the existing implementations, that
 		can be accessed by anyone that want to reproduce them. There are only some
-		points relating to the crypting engines that need to be cleared:[br]
-		The crypted text must be suitable to be sent through an IRC connection;
-		this means that some characters can not appear in the crypted text (e.g. CR,LF,NULL....).
-		KVIrc solves it in a simple way: the crypted binary data is encoded,
-		either as hexadecimal numeric string or in base64.[br]
-		An escape character has been defined to identify messages that are "crypted" from the
-		ones that are not: this character has ascii code 30 (decimal).[br]
+		points relating to the encryption engines that need to be cleared:[br]
+		The encrypted text must be suitable to be sent through an IRC connection;
+		this means that some characters can not appear in the encrypted text (e.g. CR,LF,NULL....).
+		KVIrc solves it in a simple way: the encrypted binary data is encoded,
+		either as a hexadecimal numeric string or in base64.[br]
+		An escape character has been defined to identify messages that are "encrypted" from the
+		ones that are not: this character has ASCII code 30 (decimal).[br]
 		The encoding is used in private messages only and has the following format:[br]
 		PRIVMSG <target> :<escape_char_ascii_30><encrypted message>[br]
 		ASCII 30 does not correspond to any widely used escape sequence and allows
-		mixing encrypted and plain text messages in a conversation...Well, this is not
-		so pretty but you can exchange crypted messages with one or two friends while
-		talking on a normal IRC channel: nobody else than your friends will be able
-		to understand the message; others will see senseless sequences of characters.
+		mixing encrypted and plain text messages in a conversation, well, this is not
+		so pretty but you can exchange encrypted messages with one or two friends while
+		talking on a normal IRC channel, nobody else other than your friends will be able
+		to understand the message, others will see senseless sequences of characters.
 		You will be still able to read the unencrypted messages of the other people
 		on the channel.[br] The escape character is not needed if the engine
-		performs non-crypting tasks: a charset mapper will produce text that
-		is meant to be readed by anyone on the channel, a text colorizer will
-		act in a similar way too. So the escape character is used for the "crypting"
+		performs non-encrypting tasks: a charset mapper will produce text that
+		is meant to be read by anyone on the channel, a text colorizer will
+		act in a similar way too. So the escape character is used for the encryption
 		engines only.
 
 		[big]An idea for the future implementations[/big][br]
@@ -157,7 +157,7 @@
 	KviCryptEngine::KviCryptEngine()
 	{
 #ifdef COMPILE_CRYPT_SUPPORT
-		setLastError(__tr2qs("Invalid crypt engine"));
+		setLastError(__tr2qs("Invalid encryption engine"));
 		m_iMaxEncryptLen = -1; // unlimited
 		m_deallocFunc = 0;
 #endif //COMPILE_CRYPT_SUPPORT
diff --git a/src/kvilib/ext/KviRegisteredUserDataBase.cpp b/src/kvilib/ext/KviRegisteredUserDataBase.cpp
index 591c56fb7..6738bab7d 100644
--- a/src/kvilib/ext/KviRegisteredUserDataBase.cpp
+++ b/src/kvilib/ext/KviRegisteredUserDataBase.cpp
@@ -43,7 +43,7 @@
 		user properties, notify property, avatar property
 	@body:
 		[big]Introduction[/big][br]
-		The "registered user database" is basically a set of users with associated
+		The registered user database is basically a set of users with associated
 		[doc:irc_masks]irc-masks[/doc] and properties.[br]
 		It is used to recognize users on IRC and associate properties to them.[br]
 		This works more or less like the IRC ban list, K-Line list, or invite list.[br]
@@ -53,7 +53,7 @@
 		or any other string (even with spaces). The name is an "internal identifier" for the user entry:
 		each name maps to a single entry and each entry has a single name.[br]
 		Each entry has a set of registration [doc:irc_masks]irc-masks[/doc]: these masks
-		are used to recognize the user on irc.[br]
+		are used to recognize the user on IRC.[br]
 		[br]
 		[big]Registration masks[/big][br]
 		The masks have the common IRC mask format: [b]<nick>!<user>@<host>[/b][br]
@@ -71,7 +71,7 @@
 		For this reason putting wildcards in nicknames could become a problem
 		if not used carefully (but may also be used to achieve interesting tricks).[br]
 		If you don't use wildcards in nicknames you are sure that
-		in a single irc connection, a mask will always refer to a single user.[br]
+		in a single IRC connection, a mask will always refer to a single user.[br]
 		You will commonly use the following format:[br]
 		<nick>!*<username>@*.<host>.<top>[br]
 		or[br]
@@ -79,7 +79,7 @@
 		In this way you can be 95% sure that the mask will really match the correct user.[br]
 		[br]
 		[big]Example of registration and lookups[/big]
-		Assume that you want to registere a friend of yours: Derek Riggs.[br]
+		Assume that you want to register a friend of yours: Derek Riggs.[br]
 		Derek often uses "Eddie" as his nickname
 		"stranger" as username and has a dial-up connection that makes his IP address appear as
 		<variable-number>.somewhere.in.time.org.[br]
@@ -94,16 +94,16 @@
 		On the other hand, if you dislike the users with the nickname Eddie that come from .org
 		and you're implementing an auto-kick system, the correct mask to register is "Eddie!*@*.org".[br]
 		[br]
-		KVirc ties to be smart, and always find the most correct match for an user:
+		KVIrc tries to be smart, and always find the most correct match for an user:
 		If you have two masks registered: Pragma!*xor@*.myisp.it and *!*@*.myisp.it,
-		kvirc will match Pragma!~xor@233-dyn.myisp.it with the first one even if the second
-		one matches too; the firs one is a best match.[br]
+		KVIrc will match Pragma!~xor@233-dyn.myisp.it with the first one even if the second
+		one matches too; the first one is a best match.[br]
 		[br]
 		[big]Properties[/big][br]
 		A registered user has an (eventually empty) set of properties
 		defined by name/value pairs. (In versions prior to 3.0.0 flags were used instead,
 		but revealed to be insufficient).[br]
-		KVirc recognizes some of these proprietes and associates semantic actions to it; other properties
+		KVIrc recognizes some of these properties and associates semantic actions to it; other properties
 		are left for scripting extension. Property names are case insensitive.[br]
 		One of the recognized properties is the "[doc:notify_list]notify[/doc]" property.
 		When an user is found to have this property set to a special value
@@ -238,7 +238,7 @@ KviRegisteredUser * KviRegisteredUserDataBase::addMask(KviRegisteredUser * u,Kvi
 			l->setAutoDelete(true);
 			if(!u->addMask(mask))
 			{
-				qDebug(" Ops...got an incoherent regusers action...recovered ?");
+				qDebug(" Oops! Received an incoherent regusers action, recovered?");
 				delete l;
 				l = 0;
 			} else {
@@ -251,7 +251,7 @@ KviRegisteredUser * KviRegisteredUserDataBase::addMask(KviRegisteredUser * u,Kvi
 	// Ok...add it
 	if(!u->addMask(mask))
 	{
-		qDebug("ops...got an incoherent regusers action...recovered ?");
+		qDebug("Oops! Received an incoherent regusers action, recovered?");
 		return 0; // ops...already there ?
 	}
 	append_mask_to_list(l,u,mask);
@@ -311,7 +311,7 @@ bool KviRegisteredUserDataBase::removeUser(const QString & name)
 	while(KviIrcMask * mask = u->maskList()->first())
 	{
 		if(!removeMaskByPointer(mask))
-			qDebug("Ops... removeMaskByPointer(%s) failed ?",name.toUtf8().data());
+			qDebug("Oops! removeMaskByPointer(%s) has failed",name.toUtf8().data());
 	}
 	emit(userRemoved(name));
 	m_pUserDict->remove(name);
diff --git a/src/kvilib/ext/KviSharedFilesManager.cpp b/src/kvilib/ext/KviSharedFilesManager.cpp
index 14bcf7f65..2a33f02f9 100644
--- a/src/kvilib/ext/KviSharedFilesManager.cpp
+++ b/src/kvilib/ext/KviSharedFilesManager.cpp
@@ -66,14 +66,14 @@
 		use an additional "size" parameter in the DCC GET request.[br]
 		[big]Security issues[/big]
 		This is a nice but unsecure method of sharing files.[br]
-		The user mask is a good protection but you have to use it properly!.[br]
+		The user mask is a good protection but you have to use it properly![br]
 		Setting the user mask to Nick!*@* can be easily exploited (just by making an user disconnect
 		in one of the well known ways and then by using his nickname).[br]
 		On the other side, the remote end must know exactly the visible name of the offer to request
-		and noone but you will tell him that name.[br]
+		and no one but you will tell him that name.[br]
 		In sum:[br]
 		Don't share any really important files: this *might* be like putting it on your webpage :D[br]
-		Please don't send complains if someone stoles your /etc/passwd : it is because you have permitted that.[br]
+		Please don't send complaints if someone steals your /etc/passwd : it is because you have permitted that.[br]
 */