types: Add STL-compliant Hash functor for Qt types

In order to use Qt types with std::unordered_set (and map), a
compatible hash function needs to be provided. Provide a generic
Hash<T> functor that just uses the qHash() function for the given
type.

This can be used as follows:
    std::unordered_set<QString, Hash<QString>> set;

tests: Add unit test for basic SignalProxy functionality

Add unit test cases for attached signals as well as syncable objects.
These test cases don't check for error behavior (yet); they mostly
are intended for ensuring that the upcoming refactoring of the
SignalProxy does not affect the format on the wire. As such, the test
cases mostly focus on the protocol messages sent by invoking
SignalProxy and SyncableObject functionality.

test: Add a spy type that waits for one or more signals

Introducing SignalSpy that allows to wait for one or more signals
to be emitted in test cases. Unlike QSignalSpy, it is not bound to
a particular signal on construction; instead, one has to explicitly
connect one or more signal(s) before calling wait().

test: Add a way to mock peers for SignalProxy-related test cases

Introduce a new mock class MockedPeer that allows for setting
expectations for dispatched Quassel protocol messages. Also provide
matchers to express such expectations in a straightforward way.

MockedPeer for now only supports SignalProxy messages; support for
authentication messages can be added later if needed. Note that
expectations can be set on the level of protocol messages, but things
like a testing a particular serialization, the use of network sockets,
or other lower-level implementation details are not supported, nor is
MockedPeer intended for such use cases (we'd expect specific tests for
specific peer types).

test: Add GTest printers for commonly used Qt types

Because GTest by default prints out unknown types as hexdump or other
badly readably formats, provide PrintTo functions for Qt types we use
in tests. That way, GTest will use those instead of falling back to
its own default.

Reuse Qt's own QDebug stream support to avoid having to reimplement
printing functionality for all the types. This makes it very easy
to see e.g. the contents of a QVariantMap or other complex types.

test: Add InvocationSpy and ValueSpy helper classes

For test cases testing asynchronous operations that require a running
event loop, it is convenient to have a way to wait until something
happens. Qt provides QSignalSpy to wait for a specific signal while
spinning the event loop. This is not always convenient to use, though.

Provide InvocationSpy and ValueSpy (based on QSignalSpy) that provide
an explicit way of notifying them, without having to connect a signal
first. Unlike QSignalSpy, those classes also time out when not notified
within a given time span.

Put those classes in a new library Quassel::Test::Util, which will
gain more testing-related utils over time.

test: Introduce Quassel::Test::Global library

Move things that are needed in every test case into a new library,
rather than requiring the Test::Main one (which is not going to be
linked to other test tooling which we'll introduce).

modernize: Remove custom Quassel-specific log macros

The quInfo(), quWarning(), quError() macros were introduced a long
time ago to provide custom log message handling, such as logging to
file or syslog. Such features have been directly supported for the
standard Qt log macros for a while now, using a global message handler.
The only reason for Quassel's custom macros to still exist was the
lack of an info log level prior to Qt 5.5.

As we can now rely on Qt 5.5 to be available, replace the custom
macros by Qt ones, and remove LogMessage which is no longer needed.

modernize: Remove Uncrustify config and script

Since we can now use clang-format for formatting the code, and
provide a .clang-format ruleset in the repository, we can remove
the ancient Uncrustify configuration and script.

modernize: Reformat ALL the source... again!

It's been more than six years since we last used an autoformatter
on the codebase. Tooling has progressed, so has the language and
of course our personal preferences.

Use clang-format this time to reformat the whole codebase, following
the rules laid out in .clang-format (which one can use for configuring
an IDE, too, if it supports autoformatting). Overall, the new style
is not too different from what we used before, with one significant
change:

We now attach pointer/reference indicators (*&) to the type rather
than the name, i.e. we left-align. While this is a major deviation
from the Qt style which we use for almost everything else, it aligns
more closely with many other projects, as well as the C++
documentation and STL. It also makes more sense semantically,
because */& are really part of the type.

Other changes include (but are not limited to):

- Use only one blank line between function definitions
- Categorize includes from generic/system to local, sorting each
  category alphabetically. The generic-to-local sort order seems to
  be more common than the other way round, so we use that.
- In .cpp files, the corresponding header is always included first.
  This is a general recommendation, because it makes it harder to
  accidentally introduce a reliance on transitive includes in headers.
- Consistently break initializers in ctors before the comma, so the
  commas are left-aligned together with the colon.
- Use two spaces between code and trailing comments.

Note that sometimes even clang-format gets things wrong. In a few
places, formatting was manually fixed; however, reviewing a diff of
almost 80k lines is a rather boring task, so we didn't thoroughly
go through all the changes. Wrong formatting can always be fixed
in follow-up commits, anyway.

Note also that we don't intend to re-run clang-format on a regular
basis, nor do we want to religiously follow a hardcoded set of rules
for new code in the future. Where it makes sense, the rules may be
bent in favor of better readability or more pleasing code.

cmake: Add build-time dependency to Boost 1.56

We'll be using some Boost features in the future, so prepare the
build system to reflect that dependency.

travis: Reduce ccache size

Reduce the ccache size in order to not waste too much time packing/
extracting the cache. Since we're only building one project, 1G should
be plenty.

tests: Enable tests in Travis

Build Quassel with -DBUILD_TESTING=ON and run the tests as part of
the CI build.

tests: Convert ExpressionMatchTests into a GTest-based test case

As first contender for the newly introduced test framework, use
the recently added ExpressionMatchTests class. Convert to use
GTest, and move into the new home for Quassel unit tests (the
tests/<module>/ directory).

With this, "make test" (or "ninja test") actually does something
if Quassel is configured with -DBUILD_TESTING=ON.

test: Add build system support and a main function for unit tests

Add a new CMake option BUILD_TESTING (defaults to OFF) that, if
enabled, will build unit tests and related requirements.

Add a new library Quassel::Test::Main that provides a main function
for test cases.

Add a new CMake macro quassel_add_test for making the adding of test
cases convenient by hiding most of the boilerplate.

Test cases should #include "testglobal.h", so they automatically have
access to GTest/GMock macros as well as the imported main function.

test: Bundle GTest/GMock 1.8.1 sources and provide a find script

GTest/GMock is a unit testing framework that we want to use for
writing unit tests for Quassel in the future. Since Google
recommends building the test libraries with the same flags and
settings as the code under test, we should build them as part of
Quassel's build process rather than relying on system-provided
libraries.

Because most distros don't seem to package the GTest/GMock sources,
bundle them with Quassel. The upstream sources are unmodified,
although the set of files shipped is trimmed down significantly
in order to not needlessly blow up the repo size.

Provide FindGTest.cmake, which builds the libraries from the
bundled sources.

modernize: Require member function pointers for Settings::notify()

Require member function pointers for Settings::notify() and
Settings::initAndNotify(). This brings us one step closer to being
SLOT-free.

modernize: Remove old-style slot usage in NetworkModelController

Use member function pointers in NetworkModelController and related
classes, instead of old-style slots and invokeMethod().

modernize: Don't use apparent connect-by-name slots in MainWin

Rename slots named "on_*" to follow our naming conventions, and avoid
association with the very old and very discouraged connect-by-name
feature in Qt (also known as "auto-connection slots"). MainWin doesn't
even use this feature, so we should not confuse casual readers.

modernize: Migrate action-related things to PMF connects

In our quest to get rid of the deprecated use of slots, refactor
Action and ActionCollection to require pointer-to-member-function
connects. Ensure nobody accidentally still uses SLOT through a static
assertion.

Add a convenience function to ActionCollection for adding lists of
actions. While we're at it, also rework ActionCollection's optional
KDE Frameworks support to simplify things.

Adapt the rest of the code accordingly.

uisupport: Provide helpers for dealing with widget changes

In many places, we want to connect to a widget's changed signal,
i.e. a signal that is emitted whenever the widget changes. This
requires a great deal of boilerplate especially in settingspages,
since the signal to listen to varies between widget types.

Provide helpers that automate most of this by matching the given
widget against a static list of supported widgets' changed signals,
and connecting automatically. A sprinkle of template magic makes
it very easy to support a bunch of different widget types in a generic
way.

Make use of this feature to get rid of the remaining old-style
connects in SettingsPage. Also migrate a couple of specific
settingspages as proof-of-concept and API validation; others
can follow over time.

common: Provide helper for getting member function traits

Add a new header funchelpers.h that contains helpers for dealing
with member function traits. MemberFunction<Callable> provides
the class, return and argument types of the given Callable, as well
as a compatible std::function type.

modernize: Replace most remaining old-style connects by PMF ones

Manually replace old-style connects (using the SIGNAL/SLOT macros)
by the much more efficient and typesafe pointer-to-member-function-
based ones.

This fixes the cases where clazy could not auto-migrate to the new
syntax for a variety of reasons. In most of the cases, we need to
remove overloads or explicitly select the desired one, because the
plain syntax cannot deal with overloads. Another issue is trying
to connect to signals in a baseclass that are only declared in a
derived class (which works with the old-style runtime connection
handling, but obviously no longer with the compile-time version).

Also do some selected cleanups in places.

common: Provide helper for resolving overloaded function pointers

The pointer-to-member-function connect syntax cannot directly deal
with overloaded method signatures. Provide a helper to avoid ugly
static_cast incantations:

  #include "util.h"
  connect(this, selectOverload<int, QString>(&MyClass::mySignal), other, &Other::mySlot);

This helper can be used for both signals and slots.

qtui: Fix initialization order after switching to PMF connects

Seems like switching to PMF connections has changed the order signals
are processed in, resulting in the UI being initialized after the
session manager asks for saving the UI state (for whatever reason).

Make this less fragile (and avoid a crash when using KDE) by
connecting to the session manager only after initializing the UI, and
replace the initUi() slot by a lambda while we're at it.

clazy: Convert many old-style connects into function pointer based

Since Qt5, signal/slot connections can be expressed using function
pointers rather than the SIGNAL/SLOT macros. This is a) much more
efficient, and b) provides a compile-time check for the sender
and receiver being compatible.

Let clazy auto-fix old-style connects where it can. However, a lot of
occurrences remain where we'll need manual intervention for one
reason or another.

modernize: Use ranged-for loops in some obvious cases

Some old-style loops can be automatically converted by clang-tidy
to use ranged-for.

modernize: Use 'while(true)' instead of 'while(1)'

modernize: Use std::make_unique

modernize: Use C++ versions of system headers

System headers ending on .h are deprecated; use the c* version
instead.

modernize: Use raw string literals instead of escaped strings

Replace escaped strings with raw string literals in places where
it makes sense, and doesn't confuse lupdate.

modernize: Use braced-init list when returning types

modernize: Use auto where the type is clear from context

Apply clang-tidy's modernize-use-auto fix, which uses auto where
the type would otherwise be duplicated in the line (e.g. when casting
a type, or creating an instance with 'new').

modernize: Use '= default' instead of empty ctor/dtor bodies

Also remove lots of unnecessary, empty ctors and dtors.

modernize: Prefer default member init over ctor init

Where appropriate, initialize class members in the header rather
than in the constructor.

modernize: Pass arguments by value and move in constructors

If a method (or constructor) wants to store an argument in a local
variable or attribute, one should prefer passing it in by value
and moving it into the final location, rather than taking a
const reference and copying it over. In the best case, this saves
one copy, if the method is called with an rvalue.

This pattern is most frequent in constructors initializing class
members, so let clang-tidy fix this for argument types that have
move constructors.

modernize: Use 'using' instead of 'typedef'

modernize: Use override instead of virtual

Let clang-tidy fix all occurrences where override should be used
instead of virtual. Also, let it annotate member functions where
virtual was missing in the first place.

modernize: Use nullptr

Let clang-tidy fix all occurrences where nullptr should be used
instead of 0.

clang-tidy: Mark several settingspage methods as final

To avoid warnings about calling virtual methods during construction,
mark affected methods as final. It's legitimate to call things like
load() from their ctors as long as nobody inherits from them.

clang-tidy: Don't call virtual methods from CoreAccountModel's ctor

cmake: Build shared libraries (DLLs) on Windows

Since symbols are now properly marked for export, we can finally
enable the building of DLLs on Windows.

cmake: Make symbols hidden by default on GCC/Clang

With symbols now being explicitly marked as exported where needed,
there is no need to globally export all symbols anymore.
Tell CMake to set the appropriate compiler flags
(i.e. -fvisibility=hidden) for GCC and Clang so, they only export
requested symbols.

src: Mark symbols to be exported where needed

Generate export headers for the Quassel modules, and mark all
relevant classes and function to be exported so that shared libraries
can be linked against without globally exporting all symbols.
This is a hard requirement for Windows DLLs, and more efficient on
other platforms, too.

For now, this was done incrementally until everything linked properly.
In the future, we may consider explicitly defining the public
interfaces for each module, and trying to minimize the linker
interface e.g. by PIMPLing.

cmake: Support generation of export headers

For using shared libraries without globally exporting all symbols,
one has to explicitly mark classes and free functions to be exported.
This is more efficient on platforms like Linux (enabling the use
of -fvisibility=hidden on GCC/Clang), and a hard requirement for
using DLLs on Windows (which don't support global export at all).

Extend the quassel_add_module() macro with an optional EXPORT
argument, which, if provided, uses CMake's built-in support for
generating an export header that provides macros for exporting
symbols. The same macro will also import the marked symbols when
building against a library.

While we're at it, also fix the install rule to use the proper
install locations for RUNTIME/LIBRARY/ARCHIVE target types.

sigproxy: Don't expose the thread_local '_current' attribute

Windows does not allow exporting thread_local attributes in the
DLL interface. Since it's not good practice anyway to expose such
an implementation detail in the public header, make the accessor
non-inline and move the attribute into a private anonymous namespace,
removing it from the public interface.

uisupport: Let ClickableList inherit from std::vector instead of QList

Apparently, a class inheriting from a QList specialization cannot
be properly exported, while this works fine when inheriting from
std::vector instead. Since we now prefer std containers over Qt's
anyway, changing the baseclass is a Good Thing™ either way, so
just do it.

qtui: Add debug dialog for showing the resource file tree

Add a dialog in the debug menu that shows the compiled-in
resource files. This is useful for checking that resource generation
and loading works properly.

common: Simplify SyncableObject macros and usage

Since the C++11 standard defines "__func__", and modern versions
of MSVC support this, we can remove the workaround for MSVC from
the SyncableObject macros. It is no longer necessary to derive
the function name from MSVC's __FUNCTION__ (which contains the
enclosing class name), and thus the _classNameOffset__ function
declared by the SYNCABLE_OBJECT macro is no longer needed.

Repurpose the macro to define the syncMetaObject() member function
instead, and remove the no-longer needed INIT_SYNCABLE_OBJECT
macro.
The syncMetaObject() function is used by the signal proxy for
accessing the metaObject() of the base class in case there are
client- or core-specific specializations of a syncable object;
i.e. if you have Foo directly inheriting from SyncableObject,
and ClientFoo derived from Foo, the function must only be
declared in Foo, otherwise syncing won't work.

Thus, the SYNCABLE_OBJECT macro declares the function as final,
so it can't be accidentally overridden.

While we're at it, replace include guards with #pragma once in
files we touched.

qa: Remove lots of superfluous semicolons

Since we have now enabled -Wpedantic, the compiler warns us about
superfluous semicolons, of which we apparently have a lot.
Remove them.

cmake: Reorder slightly for consistency

Other modules link the main dependencies before caring about
options, so do the same for the core module.

cmake: Link resources statically, and init locally

Link resource libraries statically in order to avoid problems with
symbol exporting. Move resource initialization from main() into the
respective libraries.

cmake: Add support for static libs to quassel_add_module

We'll need this for building resource libraries, which we can't
easily export symbols from (and which also are not used more than
once).

cmake: Build shared libraries

The days of static builds are finally over. Build dynamic libraries
for all Quassel modules.

Let CMake handle the RPATH in a way that doesn't cause inconvenience;
always set an RPATH in the build tree so the correct libraries
are loaded, and also set an RPATH for installed binaries unless
they go into a system location.

Also define output directories for all build artifacts.

cmake: Modernize compile settings; require C++14

Clean up QuasselCompileSettings.cmake, treat GNU and Clang the same.
Use add_compile_options() instead of CMAKE_CXX_FLAGS. Curate the list
of compiler flags, and add sensible linker flags, too.

Check explicitly for required compiler features using CMake's
target_compile_features(), rather than hard-coding compiler versions.
The set of required features basically implies that we now require
a C++14 compiler (even though the new stuff isn't used in the code
yet).

cmake: Build Windows icon resource again

Building the Windows resource got lost while refactoring the build
system, so bring it back.

cmake: Modernize translation generation

Refactor and modernize the CMake support for translation generation.
Properly use targets, custom commands and dependencies to ensure that
files are only regenerated when needed, and avoid useless rebuilds.

Avoid individual invocations of lupdate and lrelease, which both
support processing multiple files at once.

Make use of the newly added quassel_add_resource function instead of
building the .qrc file explicitly.

Fix LINGUAS support, which was previously not working as intended.

cmake: Autogenerate most of the .qrc resource files

With the CMake support from the previous commit, resource files
can now be autogenerated. Do this for almost all resources;
the hicolor one is special because it uses aliases, and the i18n
one requires more work that is going to be added in a follow-up
commit.

Combine several of the previous resources (e.g. different icon sets)
to reduce complexity. This wasn't possible previously due to the
various configuration-specific combinations, but can now be done
dynamically by extending the glob patterns accordingly.

cmake: Add support for generating .qrc files

Most .qrc files we use just map the (partial) contents of a
directory, so that can be autogenerated. Provide CMake functions
that support this endeavour to remove the need of regenerating
resource files if directory contents changes.

Since RCC is stupid, some hacks are required to make this work,
so we can't use either autorcc nor qt5_add_resource(); we must
invoke RCC manually. Clever use of targets and custom commands
as well as external CMake script invocation ensures that the .qrc
files are always up to date even if files change, while avoiding
useless rebuilds (as is currently still the case for i18n).

cmake: Fix source-specific compile definitions

set_source_files_properties() overwrites previously specified
properties and does not have a way to append, which is bad when
e.g. conditionally adding multiple compile definitions to a file.
In this particular case, for main.cpp -DHAVE_UMASK would overwrite
-DEMBED_DATA, and thus resources would not be loaded.

Use set_property(SOURCE... APPEND PROPERTY...) instead.

cmake: Modernize cmake support for LDAP

Use a more modern, property-based find script for the LDAP libraries
and get rid of the deprecated use of LDAP_LIBRARIES and similar
variables in favor of a namespaced Ldap::Ldap target.
Set package properties for better diagnostic output at configure time.

cmake: Reorganize package finding

Use COMPONENTS to find required Qt5 modules in one go.
Don't look for QtWebKit if we already have QtWebEngine.
Look for Sonnet explicitly even when using KDE Frameworks, because
we're using its config widget and shouldn't rely on transitivity
here.
Only look for LDAP when building the core (or mono client).
Add QUIET everywhere to avoid spammy CMake warnings for optional
packages.
Add some diagnostic output indicating the versions of Qt and KF5.

cmake: Remove some compiler flags that are no longer needed

With the move to a property-based build system, we no longer need
special handling of -fPIC for Qt.

Also remove some things related to old KDE and CMake.

cmake: Set -DHAVE_UMASK only where it's needed

Avoid setting this define globally when it's only used in two
files.

cmake: Remove boilerplate from HAVE_SSL check

Instead of setting flags and includes manually (potentially
polluting global variables), just link the test program to
Qt5::Core directly and rely on property propagation.

cmake: Modernize use of Qt Linguist Tools

All Qt versions we support provide an alias target for the linguist
tools. Thus, remove the fallback for older Qt versions.

Use the LOCATION property of the tools' target instead of relying
on the corresponding QT_L*_EXECUTABLE variables.

cmake: Modernize build system

Move to the modern, property-based way of using CMake. This
simplifies a lot of things:
 - No need to manually specify interface include dirs and libraries
   of dependencies
 - No need to carry around variables
 - Clear separation of local and global dependencies and definitions
 - No need for hacks to make the triple-executable thing work

Provide convenience functions to set up library and executable
targets. This will make it very easy in the future to split up
some modules, as well as move towards using shared libraries.

Use the modern, property-based way of using Qt, too. This removes
the need for the deprecated qt5_use_modules() macro, and a bunch
of manual things we had to do to get the compile flags right
for the different Quassel executables.
Also make use of CMake's AUTOUIC and AUTORCC to avoid a bunch of
boilerplate for dealing with .ui files and Qt resources.

Move the .ui files from their subdirectory into the qtui directory,
since the separation doesn't really make too much sense. We'd rather
want to split the QtUi module into smaller parts/libraries.

Remove a bunch of unnecessary stuff from the CMake files.

cmake: Remove custom build types

The non-standard build types DebugFull and Profile (which we took
from KDE4) are not supported by e.g. Qt, so remove them.

Improve build type handling; show the supported values in CMake GUIs
and provide a sensible default if none is given (Release unless
a .git directory is present, in which case Debug is default).

cmake: Remove support for building static binaries

Building and running static binaries has become increasingly
difficult on modern systems, in particular when involving
complex libraries like Qt due to their reliance on plugins and
other dynamically loaded resources. It is also a security risk,
as upgrades to system libraries won't apply to the static binary.

Having a static quasselcore binary was quite useful when it was
hard to get Qt on an X11-less box, but these days all major distros
support modular Qt, and can provide Quasselcore packages that
don't require graphical dependencies. Consequently, we no longer
intend to offer static binaries.

Thus, remove the corresponding hacks from the build system.

cmake: Use official CMake config for QCA

QCA has been shipping with a CMake config for a while, so use this
rather than providing a custom find module. Remove the custom
modules, as well as FindLibraryWithDebug.cmake which was only used
by them.

Move KeyEvent from common into core, since it's only used there.

cmake: Use official FindBacktrace rather than custom FindExecInfo

Newer versions of CMake ship their own FindBacktrace.cmake module,
which replaces the FindExecInfo.cmake module so far shipped by
Quassel. The official module is also a bit more thorough in terms
of cross-platform support.

To avoid duplication, remove Quassel's custom find module and use
the official one instead.

cmake: Bump minimum required CMake version to 3.5

This is the version shipped with Ubuntu 16.04 "Xenial", so
use this as a minimum requirement.

cmake: Only require a C++ compiler

With miniz gone, the only reason to still specify both C and CXX
as project languages is the use of the check_include_file cmake
macro.

Turns out there's a C++ version of that one, too; so use it.

cmake: Make zlib a required dependency, remove bundled miniz

These days, zlib should be easily available on all platforms we
support, so make it a required dependency. This allows for removing
the bundled drop-in replacement miniz.

common: Rework command line option handling

Since we can now rely on Qt5's QCommandLineParser, there is
no longer a need for an abstraction for command line parsing.
Use QCommandLineParser directly, and remove the now obsolete
AbstractCliParser and its various implementations.

Move command line parsing into Quassel::init(), which allows for
using translated strings. Make user-visible strings translateable.

Remove the long-deprecated --datadir option for now (may come
back if we decide to allow for specifying the database location
independently of config files).

common: Initialize translations in Quassel::init()

In order to have localized strings during initialization, e.g. for
command line options, the translation catalogue must be loaded
early.

Since at this point the UI configuration is not available yet,
the system locale is used. QtUi will reload translations afterwards
later if a language different from the system locale is configured
for the UI.

qt4-b-gone: Initialize data dir paths on demand

Since special handling for KDE4 data locations was removed, it is
no longer required to set the paths from the outside. Simply
initialize the paths on first use.

qt4-b-gone: Reorganize the initialization sequence

KDE4 required special handling during initialization, because command
line arguments needed to be parsed before instantiating the
application object. Since this is no longer required, the sequence
can now be simplified.

To prepare for enabling early translations (also for the CLI parser),
instantiate the application first, then explicitly initialize the
Quassel instance in main() (which will later both load translations,
and handle CLI options). Only then also initialize the application
itself.

Since initialization errors are handled by exceptions anyway, get rid
of the return values for the various init() methods, too.

qt4-b-gone: Remove bundled sha512 implementation

Qt5 supports SHA512 natively, so we no longer need to ship an
external implementation.

qt4-b-gone: Remove all code supporting Qt < 5.5 and KDE4

Remove compatibility code for Qt versions we no longer support.

qt4-b-gone: Remove support for Phonon

Phonon is superseded by QtMultimedia, which offers everything we need
for playing audio notifications.

qt4-b-gone: Remove support for libindicate

libindicate-qt only exists for the dead Qt4, so remove support
for it.

cmake: Bump minimum required version of Qt to 5.5.0

This version of Qt is provided in Ubuntu "Xenial" 16.04, which is our
new baseline for distro support.

cmake: Remove build system support for Qt4/KDE4

In our quest to modernize the codebase, remove support for the
long-dead Qt4 libraries (and consequently, also for integration
into KDE4) from the build system.

travis: Add bionic as target distro

This allows us to test building Quassel against a recent release
of Ubuntu, as well.

travis: Add jobs for building against KDE Frameworks

Define CMake options in a more generic way, and use this to define
builds against KDE Frameworks.

travis: Use docker-based builds, new baseline

Perform Linux builds in docker images, which allows us to freely
define the build environment rather than relying on the Travis host
system.

Use Ubuntu 16.04 "Xenial" as the new baseline for Quassel, allowing
us to make use of a more modern toolchain.

Reorganize and modernize travis.yml in general.

Post-release version bump

Bump version for release

Update ChangeLog

Minor cleanup of BufferView

Fix some nitpicks.

Allow selecting the search result when searching for buffers

If multiple buffers are displayed when filtering by name, allow
selecting one of the using the up/down keys. This makes it possible
to jump to a buffer other than the topmost.

common: Fix syncing of BufferViewManager

Two syncable methods where accidentally demoted from being slots,
so adding/removing buffer views would not be synced anymore.

Fix this by making those methods slots again.

qtui: Make the debug log a proper dialog

For some reason unbeknownst and shrouded in ancient mystery, the
debug log was displayed in a naked widget, which caused it to not
be rendered in a window when using not-so-smart window managers
(such as Windows™).

Make the debug log a proper dialog, and also fix the close button
not being part of a platform-agnostic QDialogButtonBox, while we're
at it.

core: Avoid Clang warning for inconsistent override

ircuser: Fix setting of away message time by pre-0.13 cores

IrcUser::setLastAwayMessage() is called by pre-0.13 cores (newer
cores call setLastAwayMessageTime() instead). Fix wrong use of
QDateTime::from[M]SecsSinceEpoch(), which is a static method returning
a new QDateTime instance rather than a modifying setter.

Also fix signatures passing primitive types as const refs.

qtui: Disable web preview by default

Upon popular request, disable the web preview by default. This
feature tends to surprise unwitting new users that just happen
to hover over a questionable link, and the preview's functionality
is limited anyway with today's complex websites.

The web preview can still be enabled explicitly in chatview settings.
Existing configurations are unaffected by this change.

Fix the order of the Davids

Bump version for release

Update ChangeLog