Installation


General notes for the installation of the release 4.0 of KVIrc

  1. Minimal Requirements
  2. Configuring the Environment
  3. Interactive Mode
  4. Compiling
  5. Compiling on MacOS X
  6. Compiling on Win32
  7. Hacker-level Installation
  8. Creating a KVIrc Package

Minimal Requirements

In order to compile KVIrc 4.0 you need at least these softwares:

Qt GUI Toolkit

If your distro has KDE installed then Qt is already installed. If not, simply install qt4 from your distro's repositories.

So before running cmake make sure that the environment variable $QTDIR points to the right location. This will help in finding the correct version of Qt.

You might eventually set it with the command:

# export QTDIR="your qt dir"

On my system qt is installed in /usr/lib64/qt so I actually execute:

# export QTDIR=/usr/lib64/qt

To check you have the right version of Qt, simply run:

# qmake -v

On my system the output is:

QMake version 2.01a
Using Qt version 4.5.1 in /usr/lib64/qt/lib

If you have multiple versions of Qt4 installed in your system and you want to use a specific version, exporting QTDIR won't suffice. Since the CMake module searching for Qt4 uses qmake itself to determine the Qt4 library dir, you can set your PATH to have CMake using using your preferred qmake version:

#PATH=/opt/qt4.5/bin/:$PATH cmake ..

Please note that compiling with KDE4 support enabled will force kvirc to link against the Qt4 version that KDE4 is using, and this may lead to problems in linking. Disabling KDE4 support is the only known solution at the moment.
Note also that you'll need to override the Qt libraries used when running KVIrc:

#LD_LIBRARY_PATH=/opt/qt4.5/lib/ kvirc4

CMake

This is usually included in the last distros.
To check which cmake you have, simply run

# cmake --version

On my system the output is:

# cmake version 2.6-patch 4

C++ Compiler

You need a decent C++ compiler. Usually under linux it is gcc from GNU tools. It is preferred to use gcc 4.3.
To check your gcc version, just run:

# gcc -v

On my system the output is:

Reading specs from /usr/lib64/gcc/x86_64-slackware-linux/4.3.3/specs
Target: x86_64-slackware-linux
Configured with: ../gcc-4.3.3/configure --prefix=/usr --libdir=/usr/lib64
--enable-shared --enable-bootstrap --enable-languages=ada,c,c++,fortran,java,objc
--enable-threads=posix --enable-checking=release --with-system-zlib
--disable-libunwind-exceptions --enable-__cxa_atexit --enable-libssp
--with-gnu-ld --verbose --disable-multilib --target=x86_64-slackware-linux
--build=x86_64-slackware-linux --host=x86_64-slackware-linux
Thread model: posix
gcc version 4.3.3 (GCC)

Pthread Implementation

This is usually included in your distribution and is probably already installed. The library is called libpthread.so.
You can look for it with the "find" command:

# find / -name libpthread.so

On my system the output is:

# /usr/lib64/libpthread.so

If you don't have it (CMake will tell you) you can download it from your favorite GNU mirror.
The configure script will also fail if the library is hidden somewhere on your system (eg. not in /lib , /usr/lib or /usr/local/lib): you should probably move it.

Dynamic Linker Interface

You need the dynamic linker interface library libdl.so.
This is usually installed on your system , so don't care until configure complains about it. Some system have the interface builtin in libc.

KDE (Optional)

If you want to compile the KDE integration support you obviousy need KDE.
The kdelibs package should suffice.

So before running cmake make sure that the environment variable $KDEDIR points to the right location.

You might eventually set it with the command:

# export KDEDIR="your kde dir"

In my case KDE is installed in /usr so I use:

# export KDEDIR=/usr

GNU gettext (Optional)

If you want the translations to non-english languages to work then you need the GNU gettext package. In particular KVIrc uses the msgfmt program.

This is usually included in your distribution and is probably already installed. You can check it by running:

# msgfmt --version

KVIrc will not complain if the command above is missing: it will just skip the creation of the translation files.
If the command above fails then you need to install the gettext package if you want any language other than english.

OpenSSL (Optional)

If you want the secure socket layer (SSL) support to be compiled you need the OpenSSL library and headers (libssl.so and openssl/ssl.h).

Perl (Optional)

If you want to generate the on-line documentation you also need perl: any version will do (I guess).

If you want perl scripting support to be compiled you need a working perl installation. Your libperl.so MUST be compiled with the MULTIPLICITY option.
You can check it with perl -V
The way external software can emebed perl has changed between perl version 5.8 and 5.10; KVIrc should play nice with perl if >= 5.004, but 5.10 is strongly suggested, since future updates can break back compatibility.

Sound System (Optional)

If you want DCC VOICE to support the GSM codec, you need a recent copy of libgsm.
This is not strictly required at compile time since KVIrc will look for the library at run-time, and only if the DCC VOICE with the GSM codec is requested.
You can check for libgsm using the "find" command:

# find / -name libgsm*

On my system the output is:

# /usr/lib64/libgsm.so

This library is included in most distributions. Some distros ship only the static version of the library "libgsm.a": if the previous find returned only something similar to "/usr/lib64/libgsm.a", you might create manually the shared archive by running:

# cd /usr/lib64
# ld --whole-archive -shared -o libgsm.so.1 libgsm.a
# ln -s libgsm.so.1 libgsm.so
# ldconfig

If you don't have it installed at all, you might have a look in your distribution CD, or download it from the web

If you want the /snd plugin to play various audio formats you either need a running sound system like phonon, a running sound daemon like esd or a reasonably recent audiofile library. Without these KVIrc will be only able to play *.au files.


Configuring the Environment

Since KVIrc 4.0 uses CMake as build system, we have to use it to create the Makefile's rules for make program.
To do it, we encourage the "out-of-source" building: build all files without dirtying the sources directory.

# mkdir release
# cd release
# cmake [your options] ..

In this way you have just created an out-of-source environment useful to have a clean working directory.
Note that the final dots are required or cmake will NOT create the right environment.

The CMake rules support some flags. If you don't specify them, CMake will try to make a good environment for you :)
To use these flags, you have to pass a bool value or a string.

For example, to install in /usr instead of /usr/local and disable Phonon support, the command would be:

# cmake -DCMAKE_INSTALL_PREFIX=/usr --DWITHOUT_PHONON=1 ..

Here's a list with explainations:

  • -DDEBUG / -DWITH_DEBUG
    Compiles the executable with debug symbols.
    Useful to report bugs.
  • -DVERBOSE
    Generate verbose output when compiling.
  • -DCMAKE_INSTALL_PREFIX=/path
    It will install all stuff under /path directory
  • -DLIB_SUFFIX=suffix
    It will install libkvilib and kvirc modules under ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX} directory. It defaults to an empty suffix. Mainly used for 64 bit distros (-DLIB_SUFFIX=64).
  • -DCOEXISTENCE
    Append version information to kvirc and libkvilib, so that different KVIrc versions can cohexist in the same system.
  • -DUSE_ENV_FLAGS
    KVIrc install rules won't try to figure out and set CMAKE_C(XX)_FLAGS; instead, it will let CMake use the ones from environment variables. Activating this flag will override -DDEBUG.
  • -DCMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT
    It will re-initialize the installation path to a good default.
    Following compilations should use the correct path value cached by CMake.
    This flag is useful to solve MacOS X install problems.
  • -DCOMPILE_MACOSX_UNIVERSAL_BINARY
    Compile universal binary for MacOS X platform
  • -DUSE_PCH
    Use pre-compiled headers
  • -DWITHOUT_PHONON
    Disable Phonon audio backend support.
  • -DWITHOUT_OSS
    Disable OSS audio backend support. This automatically disables Audiofile support, too.
  • -DWITHOUT_AUDIOFILE
    Disable Audiofile audio backend support.
  • -DWITHOUT_ESD
    Disable Esd audio backend support.
  • -DWITHOUT_QTDBUS
    Disable Qt-DBus support.
  • -DWITHOUT_QTWEBKIT
    Disable Qt-WebKit support.
  • -DWITHOUT_KDE4
    Disable KDE4 support.
  • -DWITHOUT_SSL
    Disables the Secure Socket Layer support. The SSL support is automatically enabled if OpenSSL is detected by CMake.
  • -DWITHOUT_CRYPT
    Disables the cryptographic engines and the whole cryptography/text transformation support. Produces a slightly smaller executable
  • -DWITHOUT_IPV6
    The IPv6 support is compiled by default on the platforms that support it: this option disables it.
    Even if you have a plain IPv4-only connection, you might want to keep the IPv6 support: you will be able to lookup IPv6 hostnames.
  • -DWITHOUT_TRANSPARENCY
    This option disables pseudo-transparency support.
    The pseudo transparency support makes the KVIrc windows look like semi-transparent (this is NOT real transparency: this is just a nice-looking hack).
    If KDE support is enabled, KVIrc will have an option that makes all windows use a faded KDE desktop background image as background. Without KDE support you will be able to choose a fake background image and use it as background. (You can still choose your desktop wallpaper: this will (more-or-less) work in all the window managers).
    It is cool-looking but usually eats some memory when enabled.
    It also eats some executable size.
    So this option allows to disable the pseudo-transparency.
  • -DWITHOUT_PERL
    Forcibly disable perl support.
    You will not be able to use perl scripts inside KVIrc.
  • -DWITHOUT_PYTHON
    Forcibly disable python support.
    You will not be able to use python scripts inside KVIrc.
  • -DWITHOUT_IPC
    Disables support for inter-process communication.
    You will be not able to send remote commands to running KVIrc sessions: this basically means that every time you run the KVIrc executable, a new session will be started.
    If you don't use this switch, a new session will be started only if no session is running on the same display or "new session" has been forced by a commandline switch.
    If a session is already running, the commandline will be passed to that session via IPC (X-event-based communication).
    This option saves some KB of the KVIrc executable, so if you're really short in memory, you might use it, otherwise, IPC is a nice feature.
  • -DWITHOUT_GETTEXT
    Disables the use of GetText to generate translation files.
  • -DWITHOUT_DOXYGEN
    Disables docs generation through Doxygen.
  • -DWITHOUT_SYSTEM_MEMMOVE
    This will disable the use of the system memmove() memcpy() and memset() functions and enable the bundled implementations. Use it if you have undefined references to these functions while compiling.
  • -DWITHOUT_GSM
    Explicitly disable the usage of the GSM library. This will disable the DCC VOICE GSM codec but might help when the compilation stops complaining of something related to GSM :)
  • -DWITH_ix86_ASM
    KVIrc contains some ix86 assembly routines that *could* performs some things faster (this is not always true, depends on the compiler).
    You might want to try it if your KVIrc seems to be really slow...
  • -DWITHOUT_DCC_VOICE
    Explicitly disable the DCC VOICE sound support. This might help if you have problems in compilation of src/modules/dcc/voice.cpp.
    It will disable the sound support (and thus make DCC VOICE not usable).
  • -DWITH_MEMORY_PROFILE
    Debug stuff... enables memory allocation profiling (don't use it :)
  • -DWITH_MEMORY_CHECKS
    Enables malloc() memory checks. This will print a nice message if your system goes out of memory...
    It can't save you from buying new RAM, but at least you will know that your system went out of memory and it is not a proper kvirc fault.
    Actually you probably have no reason in using it.
  • -DMANUAL_REVISION
    Manually set a revision number if subversion is not found on your system.
    This is useful mostly on windows.
  • -DWITH_PIZZA
    Add some pizza for dinner :)
  • -DWITH_BEER
    Add some beers to chat :)

Interactive Mode

The CMake build system provide also an interactive mode to configure the environment before compiling.
Again, we encourage the "out-of-source" building: build all files without dirting the sources directory.

# mkdir release
# cd release
# ccmake ..

Now you're in interactive mode, just follow the instructions on screen to configure your compilation environment.


Compiling

This step is easy :)
Cross your fingers and run:

# make

If your make is not a GNU make (this happens on FreeBSD for example) you should use "gmake" instead.
The compilation process will take from 3-4 minutes to some hours depending on the machine capabilities and load.
If you have a slow cpu but have a couple of computers in a lan you might consider using distcc to distribute the compilation.

Once the compilation has been successfull, run:

# make install

Same as above: use "gmake install" if your make is not GNU make.

This will install the executable in /usr/local/bin (if you don't have specified a different -DCMAKE_INSTALL_PREFIX option in the cmake rules), the libraries in /usr/local/lib (if you don't have specified a different -DLIB_SUFFIX option in the cmake rules) and the shared data in /usr/local/share/kvirc.

Make sure that /usr/local/lib is in your /etc/ld.so.conf , if it isn't there, put it there and run:

# ldconfig

If you have decided to use the KDE support the installation might have placed all these files in your $KDEDIR tree instead of /usr/local.
In this case you should be OK since KDE requires its library dir to be in /etc/ld.so.conf


Compiling on MacOS X

There is a detailed compilation and installation HOWTO for MacOS X systems located in the doc/ directory. It's named INSTALL-MacOS.txt


Compiling on Win32

There is a detailed compilation and installation HOWTO for Win32 systems located in the doc/ directory. It's named INSTALL-Win32.txt


Hacker-level Installation

# mkdir release && cd release
# cmake ..
# make install

Creating a KVIrc Package

CMake supports DESTDIR argument.
So, if you want to make a package for your distro, you simply have to pass it at "make install" stage: your install files will go to the choosed path.
The synthax is:

# make install DESTDIR=/tmp/kvirc-4.0

After this step, just follow your distribution's rules to make a good package for the distro you're running.

Alternatively, you can try the experimental CPack support included in CMakeLists.txt to build a package: in this case, please refer to the CPack documentation.

Have fun!

# kvirc &

That's all folks.