mark some strings untranslatable

SASL ≠ SSL

add proper msgctxts to all translations

+ various minor fixes to make gettext and Transifex happy

fix Hungarian and Portuguese translations

Make .pot Transifex compliant

Thanks a lot to Ratnadeep Debnath of Indifex

update quassel.pot

update Spanish translation

Many thanks to Rafael Belmonte <EagleScreen@gmail.com>

new file:   po/pull-from-transifex.sh

Updates translations via `tx` and commits

Update translations from Transifex

Many thanks to:
 - es: Javier Llorente <javier@opensuse.org>
 - fi: Larso <larso@gmx.com>
 - fr: GrecKo <gr3cko@gmail.com>
 - nl: redmar <redmar@ubuntu-nl.org>

import launchpad translations

update quassel.pot

update translations from transifex + minor corrections

Transifex 1.0 integration

Fix #984 without breaking topic input

Queued connection ensures that the textEdit is already reset() when InputWidget
does its thing, thus solving the history issues.

Approved by Tucos reading it 10 times. :>

Revert "Reset the input prior to processing it in order to prevent issues with per-chat history. fixes 984"

This reverts commit b56a8712f3063e93b68bfa6bd8f2ec67e955df50.

That solution had the side effect that the textEdit would already been cleared when the textEntered() signal
was sent out. This broke the assumption that consumers of that signal could access the edit's content.
We'll find a better solution for the history problems.

Log-related cli options are not present in client-only mode

Looks like KDE does not like it if we ask for an option that hasn't
been specified.

Fix compiler warnings

New gcc seems to be better at finding issues like unused (but set) variables,
so fix those.

Fix and improve logging support

It's really inefficient to parse command line options and open the logfile on every message
we log, so move that into the global Quassel class instead. Also fix CMakeLists.txt to
actually enably syslog support in the code, and allow for logging to both syslog and a file.

Introduce possibility to use syslog.

Signed-off-by: Tomas Chvatal <scarabeus@gentoo.org>

added new user input command 'showkey"

displays the crypt key for <nick|channel> if exists,
closes #1069

In kFreeBSD the library dl is not linked

The toolchain in sid on kFreeBSD has changed and the library
dl is no longer linked implicit. fixes #1072

Disables JavaScript, which fixes #1089 and other issues related to modal dialogs inside the preview crashing when the preview is destroyed.

We really don't want to depend on qtui in uisupport

It's also not needed, we can access the ActionCollection through GraphicalUi.

Make tabcompletion key configurable via shortcuts. fixes 1018

Unhide buffer when joining or querying and it was temporarily hidden. fixes #866

Don't use a const ref for bool

Add support for adding a space when tab-completing mid-sentence

Add some const correctness to Network

Reset the input prior to processing it in order to prevent issues with per-chat history. fixes 984

Fix core crash

Some CTCP requests triggered a bug in the parser; this fixes the issue.

Fix compiler warning (case value not in enum)

po: Update czech translation to be more smooth wrt rest of kde translations. Thanks to Vit Pelcak for the help.

Fixes #960 - "Core crashes after deleting a Network without disconnecting the Network first"
Note: this fixes the issue only in the 0.7 branch. Quassel Cores built from current git master
will still crash. This is due to some unsave pointer handling in the new event system, which
needs thorough fixing.

Changing the behavior how Quassel Events are processed.
They are no longer scheduled individualy but processed immediately
when they are generated. this should prohibit quassel from messing
with the space time continuum.

check for qca provider plugin, fixes #1045

Prevents core from crashing when qca provider plugin is missing.
The plugin is needed at runtime. Can occurres when packagers did
not install it.

show notices in current buffer by default

fixing typo

despammificating the pglog
This is done by switching from EAFP to LBYL (although I don't like this...)

Reworking handling of Prepared Queries in PostgreSQL
- Quasselcore should now survive PG restarts :)
- Fixes Bug #1044

Don't have CTCP ignore rules apply to ACTIONs

This accidentally slipped in 0f2c520a7. It's not at all intuitive for a user why
/me should be a CTCP event, so we don't want to apply the CTCP ignore rules to that.

Bulk-insert messages into the db (again)

This accidentally got slaughtered while moving to the new event backend. Now
messages are buffered in CoreSession until the event queue is empty, which means
that a bulk of incoming messages will completely be processed before inserting into
the database, resulting in a huge performance gain.

This buffers even more aggressive than the old version, as we process Qt events in between,
which means we'll receive and process any additional data from the socket before flushing the
message queue. The downside is that nothing will arrive in the client as long as your socket gets
flooded, but on the other hand, it will greatly reduce db I/O in such cases.

[PSQL] properly preparing insert_sender queries (in all cases) before using them

warnings--

Fix trimming

Kill IrcServerHandler and CtcpHandler

Since all incoming traffic is handled by the event system now and porting is complete,
there's no need for the pitiful reminders of the afforementioned handlers to exist anymore.

Thus, kill them with a vengeance.

Event backend porting - CTCP

This makes the last missing bits of ircd input processing use events;
CTCP handling is now done by both CoreSessionEventProcessor (for the functional parts)
and EventStringifier (for the user-visible parts).

Allow arbitrary method prefix for BasicHandler

This is mainly for making things a bit more readable in some cases. "handle" is still the
default.

Introduce CtcpParser for CTCP-related event processing

Functionality from CtcpHandler has been ported over to CtcpParser to process
IrcEventRawMessage events and generate appropriate MessageEvents and CtcpEvents from the
raw input of PRIVMSG and NOTICE.

CtcpEvents are not handled/stringified yet.

Fix event propagation

It sometimes makes sense to deliver the same event to the same object
(but different event handlers), so we shouldn't prevent that. Instead,
make sure that generic handlers are not called if at least one specialized
handler is registered.

Use late CoreSessionEventProcessor handler rather than early EventStringifier ones

Makes more sense that way. A few commands (kick, part, quit, nick) need to be handled
in the session *after* they generated a MessageEvent.

Event backend porting

PING

Event backend porting

Port netsplit handling from IrcServerHandler to CoreSessionEventProcessor, and port
related commands: JOIN, QUIT, MODE, RPL_CHANNELMODEIS (324)

Emit a new signal CoreSession::networkDisconnected(NetworkId)

Set current time on creation of MessageEvents if no other time is given

While we can probable leave the timestamp uninitialized for other event types, we certainly
always need a valid time for messages.

Event backend porting

ERR_ERRONEUSNICKNAME (432), ERR_NICKNAMEINUSE (433), ERR_UNAVAILRESOURCE (437)

Event backend porting

RPL_INVITING (341), RPL_WHOREPLY (352), RPL_NAMREPLY (353), RPL_ENDOFWHOWAS (369)

Event backend porting

RPL_ISUPPORT (005), RPL_LIST (322), RPL_LISTEND (323), channel creation time (328)
and homepage (329), RPL_NOTOPIC (331), RPL_TOPIC (332), "topic set by" (333)

Add a checkParamCount() for EventStringifier as well

Many events are not being processed by CoreSessionEventProcessor (which checks
for a sane param count for the event it handles, so we don't do that in the
stringifier usually); for those that go directly to the stringifier, we need to
check there.

Event backend porting, mostly WHOIS-related stuff

RPL_WHOISSERVICE (307), RPL_SUSERHOST (310), RPL_WHOISUSER (311), RPL_WHOISSERVER (312),
RPL_WHOISOPERATOR (313), RPL_WHOWASUSER (314), RPL_ENDOFWHO (315), RPL_WHOISIDLE (317),
RPL_ENDOFWHOIS (318), RPL_WHOISCHANNELS (319), RPL_WHOISVIRT (320), RPL_WHOISACCOUNT (330)

Add a timestamp to events

This is not set automatically for now, as I'm not sure if it's worth the overhead
of querying the system clock for every event we create.

The timestamp is set on reception of data on the socket (i.e. a bit earlier in the chain
than in the old message handling) and carried over into IrcEvents by the IrcParser.
EventStringifier will carry over the timestamp to MessageEvents.

Introduce a flag EventManager::Silent

If this is set, the EventStringifier won't generate a MessageEvent for this event.
This is thought for the CoreSessionEventProcessor (and possibly scripts) to hide
messages in certain cases, without circumventing further processing of the event.
Example would be suppressing WHO messages on autowho.

Event backend porting

RPL_AWAY (301), RPL_UNAWAY (305), RPL_NOWAWAY (306)

Also replacing the fixed strings from the ircd by a translateable version.

Fix an issue with the event loop

Event backend porting

RPL_UMODEIS (221), RPL_STATSCONN (250), RPL_LOCALUSERS (265), RPL_GLOBALUSERS (266)

This were stubs in IrcServerHandler, they're supposed to update the network object.
I've ported the stubs so we'll actually implement that some day...

Event backend porting

AUTHENTICATE, CAP, PONG, TOPIC, RPL_WELCOME (001)

Make sure IrcEventTopic always has two params

In case of an empty topic, adding a null string in the event saves us from
specialcasing this in a few places.

Event backend porting

INVITE, KICK, NICK, PART are using the event backend now.

Add checkParamCount() which stops the event if something's wrong

Debug--

Port IrcServerHandler::defaultHandler() to the event backend

The killing has begun.

Add convenience functions for generating MessageEvents

Note that this displayMsg() takes different params than the old one. Also, the order
is now msg, sender, target instead of target, msg, sender, in order to avoid having to
specify an empty target for most calls.

Convert null strings to empty strings

The storage backend bails out when we hand over null strings, so convert those
to empty strings instead when transforming a MessageEvent into a Message. Null
strings are nicer to use and more efficient, so don't force people to avoid them
in the event handlers.

Change the order of MessageEvent ctor params

Be careful, params are specified in an order different from the old displayMsg(),
since it makes more sense like this and optimizes default arg use.

Move EventStringifier from common/ to core/ for now

We need a way to access the EventManager, which currently works through CoreSession.

Once the stringifier moves into client, we'll use Client instead. Nothing else depends
on core.

Add skeletal EventStringifier

This class is supposed to generate the user-visible messages from IrcEvents,
i.e. it generates MessageEvents. For now, this lives in the CoreSession, which consumes
and converts the MessageEvents into the usual Messages that are then sent to the client.

In the future, this whole class should move into the client, in order to move string generation
out of the core. There's no need to store plaintext strings in the database if we can as well
simply store the IrcEvents, plus this will allow per-client translations.

Introduce event filters

You can now register event filters, either by using registerObject() and providing methods
starting with "filter" (by default), similar to the process functions, or by using registerEventFilter().

These filter methods take an Event* and return a bool. If false, the event won't be delivered to the
target object at all. A typical use case would be to only accept events that are targeted to a particular
network and ignoring the rest, without having to check the net in each event handler.

Note that priority is ignored; for registerObject(), filters are added with the most specialized first,
and for registerEventFilter() you're responsible for the correct order.

Properly handle numeric events

Hook up the event system to CoreSession's legacy displayMsg() processing

Now MessageEvents are handled the same way as displayMsg() calls, and we can start
gradually replacing the latter with the former.

Use a queue for events

Using a queue ensures that events will be processed in order, i.e. if processing
an events generates new ones, those won't be handled before the first one is fully done.
We also let Qt process its own QEvents in between, in order to not block things like
network handling.

Prettify qDebug() output for events

Make IrcParser functional

IrcParser now parses incoming raw data from the ircd and generates the appropriate
IrcEvents from the input. Most of this can be automated via QMeta* stuff, though several
irc commands need special casing for decoding the input (default is just to use serverDecode(),
as this is almost always the right thing to do).

All IrcEvents thus have their parameters as properly decoded QStrings, so we don't need to care
about this anywhere else.

NOTICE and PRIVMSG get some more special handling; multiple targets are broken up into
sending one event for each, messages are decrypted if appropriate, and channel welcome messages
are properly redirected.

Add more Event specializations (IrcEvent*, MessageEvent)

++API, ++EventFlags

Add IrcParser to handle data between the ircd and Quassel

This class processes data from the ircd(via NetworkDataEvent)  and is supposed to
generate appropriate specialized events once this skeleton actually has an implementation.
IrcParser will be IrcServerHandler's successor in many respects.

Introduce NetworkEvent and children

This family of events encapsulates network-related events:
* NetworkConnectionEvent handles the network's connection state
* NetworkDataEvent handles raw data sent from or to the network socket

CoreNetwork now sends a data event to the session's EventManager.

Basic event dispatching (with priorities)

I think priorities make more sense than the prepending/appending of handlers we've had before.

Boilerplate work for CoreSessionEventProcessor

So far just a dummy object that doesn't do anything, this is supposed
to handle events that change the session state (the syncable objects) later.
We also add an EventManager instance. Oh, and some #include cleanup.

Introducing the first shiny stuff for our new event-based core backend

This adds a (very rudimentary) base class for events, and a (very rudimentary)
EventManager. The manager so far allows registering event handlers (even via explicit
methods, or by providing a QObject. In the latter case, matching slots will be automatically
registered (i.e. a method handleIrcEventJoin() will be registered as handler for
IrcEventJoin).

Fix typo

fixing build on non-mac systems. ooopsi.

fixing application menu entries and shortcuts on Mac OS

remove merge fragments from hu.po + ru.po

l10n: Updated Galician (gl) translation to 79%

New status: 741 messages complete with 4 fuzzies and 185 untranslated.

Transmitted-via: Transifex (www.transifex.net).

l10n: Updated French (fr) translation to 100%

New status: 930 messages complete with 0 fuzzies and 0 untranslated.

Transmitted-via: Transifex (www.transifex.net).

inxi bumping: 1.4.15

add placeholder to tr message

Fixing issues with multiple CTCP requests in one message

 If we receive multiple CTCP requests in one PRIVMSG we now answer with
 one packed NOTICE containing all CTCP replies. This fixes a possible
 DoS Attack rendering Quassels IRC connection useless. Upgrading is
 strongly recommended. Thanks to Jima for reporting and supporting.

Properly reject invalid handshake data

Currently, if a client attempts to configure a core's storage backend
even though it is already configured, the core will ignore the attempt
silently (e.g. the existing storage backends will simply drop the request,
but the client also won't receive an error message). This can never happen
unless you use an alternative client with a buggy handshake sequence though,
since quasselclient checks if the core is already configured beforehand.

Nonetheless, it makes sense to properly error out from the core side, just in case
we're getting new storage backends in the future that don't properly check this,
or alternative clients which might be confused by not receiving an error when they should.

Thanks to JodaZ for pointing this out.

Update ChangeLog

Unbreak ru.po again. Maybe. Hopefully. Meh