Guía para compilar KDE 4.2.0 en Mandriva Linux

## Un script de configuración de algunas variables y funciones
## necesarias para el desarrollo de KDE 4.
## Esto debe ir normalmente en el directorio ~ /. Bashrc
## de su usuario kde-devel,
## que se ejecuta cuando una sesión para ese usuario se ha iniciado.
##
## Si no utiliza un usuario separada, la primera sección con las
## variables de entorno debe ir en un script separado.

PATH=$PATH:/usr/local/bin:/usr/local/sbin
export PATH

test -s ~/.alias && . ~/.alias || true

prepend() { [ -d "$2" ] && eval $1=\"$2\$\{$1:+':'\$$1\}\" && export $1 ; }

# Otros
# puede que desee establecer un valor total de PATH
# en lugar de prepend'ing, para make
# Aségurese que su PATH KDE3 no esté aquí.
prepend PATH /usr/local/bin

# Qt
# Sólo establece las variables relacionadas con Qt
# si se ha compilado su propio Qt
# (que es realmente desalentado). Si usted usa el QT
# proveído por su distro, Salte
# esta sección. Comentándolo si es necesario.
export QTDIR=$HOME/qt-copy
prepend PATH $QTDIR/bin
prepend LD_LIBRARY_PATH $QTDIR/lib
prepend PKG_CONFIG_PATH $QTDIR/lib/pkgconfig

# KDE
export KDEDIR=/opt/kde
export KDEHOME=$HOME/.kde4
export KDETMP=/tmp/kde4-$USER
mkdir -p $KDETMP
export KDEDIRS=$KDEDIR
prepend PATH $KDEDIR/bin
prepend LD_LIBRARY_PATH $KDEDIR/lib
prepend PKG_CONFIG_PATH $KDEDIR/lib/pkgconfig
prepend QT_PLUGIN_PATH $KDEDIR/lib/kde4/plugins

export PATH
export LD_LIBRARY_PATH
export PKG_CONFIG_PATH
export QT_PLUGIN_PATH

# CMake
# Asegúrese de buscar a CMake en el lugar correcto.
prepend CMAKE_PREFIX_PATH $KDEDIR
prepend CMAKE_LIBRARY_PATH $KDEDIR/lib
prepend CMAKE_INCLUDE_PATH $KDEDIR/include

export CMAKE_PREFIX_PATH
export CMAKE_LIBRARY_PATH
export CMAKE_INCLUDE_PATH

# DBus
# Un conjunto de variables relacionadas con DBUS
# sólo si usted compiló dbus
# (que es realmente desalentado).
# Si usted usa el dbus proveído por su distro,
# salte esta variable. Descomente si es necesario.
#export DBUSDIR=$KDEDIR
#prepend PKG_CONFIG_PATH $DBUSDIR/lib/pkgconfig

# Sólo es necesario en algunos sistemas extraños
# compilando QT.
# No lo establezca a menos que tenga que hacerlo.
#export YACC='byacc -d'

# XDG
unset XDG_DATA_DIRS # to avoid seeing kde3 files from /usr
unset XDG_CONFIG_DIRS

# Puede que desee cambiar estos valores:
export KDE_BUILD=/opt/kde/build
export KDE_SRC=/opt/kde/src

# Hace una bonita salida de depuración
export KDE_COLOR_DEBUG=1
export QTEST_COLORED=1

# Make
# Le dice a muchos scripts como cambiar del directorio de fuentes
# para construir el directorio
export OBJ_REPLACEMENT="s#$KDE_SRC#$KDE_BUILD#"

# Use makeobj en lugar de make, para cambiar
# automáticamente al directorio build.
# Si usted no tiene makeobj, instale el paquete llamado kdesdk-scripts ó
# kdesdk, o visite kdesdk/scripts desde svn.
alias make=makeobj

# Descomente las líneas siguientes si DBus no trabaja.
# Si DBus no está trabajando entonces,
# cuando se ejecuta `dbus-uuidgen --ensure && qdbus`,
# usted obtiene un error.
#
# alias dbusstart="eval `PATH=$DBUSDIR/bin \
# $DBUSDIR/bin/dbus-launch --auto-syntax`"

# Una función para construir el directorio actual de KDE.
#
# Esto se basa sólo en las fuentes del actuales ~/{src,build}/KDE subdirectorio.
# Uso: cs KDE/kdebase && cmakekde
# se basará en construcción/reconstrucción de fuentes en ~/src/KDE/kdebase
function cmakekde {
local srcFolder current

if test -n "$1"; then
# srcFolder is defined via command line argument
srcFolder="$1"
else
# get srcFolder for current dir
srcFolder=`pwd | sed -e s,$KDE_BUILD,$KDE_SRC,`
fi
# si usted está en el folder src, cámbiese al directorio build
# Alternativamente, podríamos usar los comandos
# de makeobj a continuación...
current=`pwd`
if [ "$srcFolder" = "$current" ]; then
cb
fi
# Para habilitar pruebas, descomente -DKDE4_BUILD_TESTS=TRUE.
# Si usted está construyendo para el debug o el desarrollo,
# esto es recomendado
# descomente la línea -DCMAKE_BUILD_TYPE=debugfull. Asegúrese de mover
# que por encima de la línea -DKDE4_BUILD_TESTS=TRUE
# de que si deja un comentario
# comentarios. Usted puede cambiar "debugfull" a "debug" para ahorrar
# espacio en disco.
# Algunas distribuciones utiliza un sufijo de su directorio de la
# biblioteca cuando
# en x86_64 (es decir /usr/lib64) si es así, tiene que agregar
# -DLIB_SUFFIX=64
# por ejemplo.
cmake "$srcFolder" -DCMAKE_INSTALL_PREFIX=$KDEDIR \
# -DKDE4_BUILD_TESTS=TRUE \
# -DCMAKE_BUILD_TYPE=debugfull

# Descomente las siguientes los líneas para
# hacer desarrollos después de esperar
# el paso de configuración,
# de modo que el usuario puede comprobar la configuración de salida
#echo "Press to continue..."
#read userinput

# Nota: Para acelerar la compilación, cambie 'make -j2' a 'make -jx',
# dónde x es su número de procesadores +1
nice make -j2 && make install
RETURN=$?
cs
return ${RETURN}
}

# para los perezosos (¿no somos todos? :))
function cmakekdeall {
local folders

folders="kdelibs-4.2.0 kdepimlibs-4.2.0 kdebase-4.2.0 kdebase-runtime-4.2.0 \
kdebase-workspace-4.2.0 kdepim-4.2.0 phonon-4.3.0 \
kdesdk-4.2.0 kdegraphics-4.2.0 \
kdemultimedia-4.2.0 kdenetwork-4.2.0 kdeutils-4.2.0 \
kdeaccessibility-4.2.0 kdeadmin-4.2.0 kdeedu-4.2.0 kdegames-4.2.0\
kdewebdev-4.2.0 kde-l10-es-4.2.0 kdemultimedia-4.2.0 kdeplasma-addons-4.2.0 \
kdeutils-4.2.0 kdetoys-4.2.0 kdeartwork-4.2.0 kde-l10n-es-4.2.0 kdebindings-4.2.0"

cd && cs # go to src root
svn up $folders

for f in $folders; do
# Remueva la parte "|| return" si usted no quiere
# detener la construcción cuándo falla un sólo módulo.
cs $f && cmakekde || return
done
}

# Una función para cambiar fácilmente al directorio build.
# Uso: cb KDE/kdebase
# cambiará a $KDE_BUILD/KDE/kdebase
# Uso: cb
# simplemente ir al directorio build si usted está en el directorio src
# Ejemplo:
# $ pwd
# /home/user/src/KDE/kdebase
# $ cb && pwd
# /home/user/build/KDE/kdebase
function cb {
local dest

# Asegúrese que el directorio build existe.
mkdir -p "$KDE_BUILD"

# argumento de línea de comandos
if test -n "$1"; then
cd "$KDE_BUILD/$1"
return
fi
# substituye el directorio src con el directorio build
dest=`pwd | sed -e s,$KDE_SRC,$KDE_BUILD,`
if test ! -d "$dest"; then
# build directory does not exist, create
mkdir -p "$dest"
fi
cd "$dest"
}

# Cambia al directorio fuente. Igual que cb, con excepción de que este
# switchea a $KDE_SRC en lugar de $KDE_BUILD.
# Uso: cs KDE/kdebase
# cambiará a $KDE_SRC/KDE/kdebase
# Uso: cs
# simplemente ir al directorio source si usted está en el directorio build
# Ejemplo:
# $ pwd
# /home/user/build/KDE/kdebase
# $ cs && pwd
# /home/user/src/KDE/kdebase
function cs {
local dest current

# Asegúrese que el directorio source exista.
mkdir -p "$KDE_SRC"

# argumento de línea de comandos
if test -n "$1"; then
cd "$KDE_SRC/$1"
else
# substitute build dir with src dir
dest=`pwd | sed -e s,$KDE_BUILD,$KDE_SRC,`
current=`pwd`
if [ "$dest" = "$current" ]; then
cd "$KDE_SRC"
else
cd "$dest"
fi
fi
}

# Añadir la función autocompletar a cs
function _cs_scandir
{
local base ext

base=$1
ext=$2
if [ -d $base ]; then
for d in `ls $base`; do
if [ -d $base/$d ]; then
dirs="$dirs $ext$d/"
fi
done
fi
}

function _cs()
{
local cur dirs
_cs_scandir "$KDE_SRC"
_cs_scandir "$KDE_SRC/KDE" "KDE/"
COMPREPLY=()
cur="${COMP_WORDS[COMP_CWORD]}"
COMPREPLY=( $(compgen -W "${dirs}" -- ${cur}) )
}

# Eliminar comentario en la siguiente línea
# para permitir autocompletar a cs
#complete -F _cs cs

function start3app {
mkdir -p /tmp/$USER-kde
export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/bin/X11:/usr/games
export LD_LIBRARY_PATH=
export KDETMP=/tmp/$USER-kde
export KDEVARTMP=/var/tmp/$USER-kde
export KDEHOME=$HOME/.kde
export KDEDIR=/usr
export KDEDIRS=$KDEDIR
export DISPLAY=:0
eval "$@"
source $HOME/.bashrc #Reset environment variables again
}

------------------------------------------------------------------------
No somos Dioses, sólo somos Actuarios :p