#!/bin/bash
# Compiz wrapper, born as loader in Ubuntu Packages
#
# Based on:
# Compiz Manager
# Copyright (c) 2007 Kristian Lyngstøl <kristian@bohemians.org>
#
# Addons by Treviño (3v1n0) <trevi55@gmail.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
#
# Much of this code is based on Beryl code, also licensed under the GPL.
# This script will detect what options we need to pass to compiz to get it
# started, and start a default plugin and possibly window decorator.
## TODO
# Compare scripts with old beryl loader
# Fix bug loading this script on a gnome session [Fixed? Not for all! :/]
# Fix xfwc4 and others (maybe killall before - reporting needed!)
# in start_decorators (maybe) if $DECORATOR doesn't exist, use the first
# available between the $STD_COMPDECORATORS decorators...
## Default Options - Setting these you can override wrapper defaults
# Set to yes to enable verbose (-v) by default.
VERBOSE="no"
# Default Compiz arguments. Others are added to this, and the configuration can
# override ALL arguments. You can pass compiz args also by command line
ARGS="--ignore-desktop-hints --sm-disable" # --replace
# Ditto for enviromental variables.
ENV=""
# Default plugins.
# Set it to empty to make the script use the best plugins for your environment
PLUGINS=""
# All the configuration plugins available, the first found in that order will be
# selected if not called by commandline or if not set using the CONFIGPLUGIN variable
CONFIGPLUGINS="ccp gconf ini"
# Default configuration plugin. Should probably be one of $CONFIGPLUGINS.
# This parameter will override any user command line argument
CONFIGPLUGIN=""
# Default plugins to enable on first CompizConfig init
# Unneeded if you have a good libccs global.xml file
DEFAULTCCSPLUGINS="decoration move resize cube rotate minimize zoom fade wobbly dbus png switcher scale place"
# Defines the decorator and arguments.
# Set it to empty to make the script use the best decorator for your environment
DECORATOR=""
DECORATORARGS=""
# Delay in seconds before we bring up the decorator(s)
# This avoids starting the decorator before the WM is up,
# even if it shouldn't be a problem.
DELAY="1.5"
# Set to "no" to pipe all decorator error messages to /dev/null
DECOERRORS="no"
# Internal, used to process options.
TASK="normal"
# No indirect by default
INDIRECT=1
# Set compiz default library directory
COMPIZPLUGINDIR="/usr/lib/compiz/"
# Set compiz executable
COMPIZ="/usr/bin/compiz.real"
# Set your default Fallback win manager (if the wrapper can't set one for you!)
FALLBACK_WINMANAGER=""
# Set to yes to enable logging (-l) by default.
LOG="no"
# Define the file in wich log all the events (if enabled)
LOGFILE="/tmp/compiz.log"
# Echos the arguments if verbose
function verbose
{
if [ "x$VERBOSE" = "xyes" ]; then
echo -ne "$*"
fi
if [ "x$LOG" = "xyes" ]; then
touch "$LOGFILE"
if ! (echo "$*" | grep -qw "present\|sleeping\|Screen"); then
echo -ne "[$(date +"%H:%M:%S")] " >> "$LOGFILE"
fi
echo -ne "$*" >> "$LOGFILE"
fi
}
### System checks
# These are used for checking what hardware and software we're dealing with,
# so we can decide what options to pass to compiz, if it's even possible to
# start compiz.
# Check wether the composite extension is present
function check_composite
{
verbose "Checking for Composite extension: "
if xdpyinfo -queryExtensions | grep -q Composite ; then
verbose "present. \n";
return 0;
else
verbose "not present. \n";
return 1;
fi
}
function check_xdamage
{
verbose "Checking for XDamage extension: "
if xdpyinfo -queryExtensions | grep -q DAMAGE ; then
verbose "present. \n";
return 0;
else
verbose "not present. \n";
return 1;
fi
}
# Check for existence if NV-GLX
function check_nvidia
{
verbose "Checking for nVidia: "
if xdpyinfo | grep -q NV-GLX ; then
verbose "present. \n"
return 0;
else
verbose "not present. \n"
return 1;
fi
}
# Detects if Xgl is running
function check_xgl
{
verbose "Checking for Xgl: "
if xvinfo | grep -q Xgl ; then
verbose "present. \n"
return 0;
else
verbose "not present. \n"
return 1;
fi
}
# Check for presence of FBConfig
function check_fbconfig
{
verbose "Checking for FBConfig: "
if glxinfo 2> /dev/null | grep -q GLX_SGIX_fbconfig ; then
verbose "present. \n"
return 0;
else
verbose "not present. \n"
return 1;
fi
}
# Check for TFP
function check_tfp
{
verbose "Checking for texture_from_pixmap: "
if [ `glxinfo 2>/dev/null | grep GLX_EXT_texture_from_pixmap -c` -gt 2 ] ; then
verbose "present. \n"
return 0;
else
verbose "not present. \n"
if [ "$INDIRECT" -eq 0 ]; then
unset LIBGL_ALWAYS_INDIRECT
INDIRECT=1
return 1;
else
verbose "Trying again with indirect rendering:\n";
INDIRECT=0
export LIBGL_ALWAYS_INDIRECT=1
check_tfp;
return $?
fi
fi
}
# Check for non power of two texture support
function check_npot_texture
{
verbose "Checking for non power of two support: "
if glxinfo 2> /dev/null | egrep -q '(GL_ARB_texture_non_power_of_two|GL_NV_texture_rectangle|GL_EXT_texture_rectangle|GL_ARB_texture_rectangle)' ; then
verbose "present. \n";
return 0;
else
verbose "Not present. \n"
return 1;
fi
}
function check_xsync
{
verbose "Checking for XSync extension: ";
if xdpyinfo -queryExtensions | grep -q SYNC ; then
verbose "present. \n";
return 0;
else
verbose "not present. \n" ;
fi
}
function check_vesa_or_vga
{
verbose "Checking for VGA or VESA session: ";
if egrep -q "(vga|vesa)_drv\.so" /proc/$(pidof X)/smaps; then
verbose "present. \n"
return 0
else
verbose "not present. \n" ;
return 1
fi
}
# Counts how many screens we have, and the base value for DISPLAY=
# so we can easily start one decorator per screen
function check_multiscreen
{
SCREENS=$(xdpyinfo | grep "screen #" | wc -l)
verbose "Detected $SCREENS screen(s)\n";
if [ "$SCREENS" == "1" ]; then return 0; fi;
verbose "Multiscreen enviromental detection: \n"
DISPLAYBASE=$(xdpyinfo | grep name\ of\ display | sed 's/.* display: *//' | sed 's/\..*//')
verbose "\tDetected $DISPLAYBASE as the base of the DISPLAY variable\n";
SCREENNUMBERS=$(xdpyinfo | grep "screen #" | sed -r 's/screen #(.):/\1/')
for a in $SCREENNUMBERS ; do
MULTIDISPLAY[$a]=${DISPLAYBASE}.$a
verbose "\tMULTIDISPLAY[$a] set to: ${MULTIDISPLAY[$a]}\n";
done
}
function possible_check
{
if [ "$1" = "1" ]; then
echo "Fatal: Failed test: $2";
return 1;
fi
return 0;
}
# Returns true if we think it's actually possible to start compiz
function check_possible
{
POSSIBLE="1"
if [ "$XGL" = "0" ]; then POSSIBLE=0; return 0; fi
if ! possible_check "$TFP" "texture_from_pixmap support"; then return 1; fi
if ! possible_check "$NPOT" "non-power-of-two texture support"; then return 1; fi
if ! possible_check "$FBCONFIG" "FBConfig"; then return 1; fi
if ! possible_check "$COMPOSITE" "Composite extension"; then return 1; fi
if ! possible_check "$XDAMAGE" "XDamage extension"; then return 1; fi
if ! possible_check "$XSYNC" "XSync extension"; then return 1; fi
POSSIBLE="0";
return 0;
}
### Work functions
# Builds a new-line seperated string of enviromental variables we might want
function build_env
{
if [ $NVIDIA -eq 0 ]; then
ENV="__GL_YIELD=NOTHING "
fi
if [ $INDIRECT -eq 0 ]; then
ENV="$ENV LIBGL_ALWAYS_INDIRECT=1 "
fi
if [ $XGL -eq 0 ]; then
if [ -f /usr/lib/nvidia/libGL.so.1.2.xlibmesa ]; then
ENV="$ENV LD_PRELOAD=/usr/lib/nvidia/libGL.so.1.2.xlibmesa"
verbose "Enabling Xgl with nVidia drivers...\n"
fi
if [ -f /usr/lib/fglrx/libGL.so.1.2.xlibmesa ]; then
ENV="$ENV LD_PRELOAD=/usr/lib/fglrx/libGL.so.1.2.xlibmesa"
verbose "Enabling Xgl with fglrx ATi drivers...\n"
fi
fi
}
# Builds the argument list
function build_args
{
if [ $NVIDIA -eq 0 -a $XGL -ne 0 -a $INDIRECT -ne 0 ]; then
ARGS="--loose-binding "$ARGS
fi
if [ $INDIRECT -eq 0 ]; then
ARGS="--indirect-rendering "$ARGS
fi
}
# Prints usage
function usage
{
echo "Usage: $0 [-r <env|args>] [-v] [-h] [-d] [-w] [-c <decorator> ]"
echo -e " [ options ] [ plugins ]"
echo -e "-r\t outputs recommended values for either enviromental variables"
echo -e " \t or arguments."
echo -e "-v\t Verbose: Output the result of each individual test"
echo -e "-l\t Log: Enable logging of all the verbose events in $LOGFILE"
echo -e "-h\t Display this message"
echo -e "-d\t Dry run: Do everything, but don't start."
echo -e "-w\t Only start default window decorator(s). One per screen."
echo -e "-c\t Restart using the passed window decorator(s). One per screen."
echo -e "options\t Pass to compiz any option given by --help."
echo -e "plugins\t Enable any compiz plugin, generally you can set (overriding default)"
echo -e " \t one of the configuration plugins [${CONFIGPLUGINS// /, }]"
}
# Parses options
function parse_options
{
while getopts "r:-:vlhdwc:" ARG
do
if [ "x$ARG" = "x-" ]; then
if [ "$OPTARG" = "help" ] || [ "$OPTARG" = "version" ]; then
$COMPIZ --$OPTARG
exit 0
elif ! (echo "$ARGS" | grep -qw -- "--$OPTARG"); then
ARGS="$ARGS --$OPTARG"
verbose "Adding compiz option --$OPTARG to command line\n"
fi
elif [ "x$ARG" = "xr" ]; then
TASK="RECOMMEND";
if [ "x$OPTARG" = "xenv" ]; then
REC="env";
elif [ "x$OPTARG" = "xargs" ]; then
REC="args"
elif [ "x$OPTARG" = "xboth" ]; then
REC="both"
else
echo "Invalid recommend argument"
usage
exit 1
fi
elif [ "x$ARG" = "xv" ]; then
VERBOSE="yes"
elif [ "x$ARG" = "xl" ]; then
LOG="yes"
if (touch "$LOGFILE") 2> /dev/null; then
STDOUTPUT="$LOGFILE"
ERROUTPUT="$LOGFILE"
verbose "Enabled logging in $LOGFILE\n"
else
echo "I can't log in $LOGFILE"
fi
elif [ "x$ARG" = "xd" ]; then
DRY="yes"
elif [ "x$ARG" = "xw" ]; then
TASK="WINDOWDECORATOR";
DELAY=0
elif [ "x$ARG" = "xc" ]; then
DECORATOR="$OPTARG"
DECORATORARGS="--replace"
DELAY=0
else
usage
exit 0
fi
done
if [ $TASK != "WINDOWDECORATOR" ]; then
for arg in $*; do
if ! (echo "$arg" | grep -q -- "^-") &&
! (echo "$PLUGINS" | grep -qw -- "$arg") &&
! (echo "$CONFIGPLUGINS" | grep -qw -- "$arg") &&
[ -f "$COMPIZPLUGINDIR/lib${arg}.so" ]; then
PLUGINS="$PLUGINS $arg"
verbose "Adding compiz plugin $arg to command line\n"
elif (echo "$CONFIGPLUGINS" | grep -qw -- "$arg") &&
[ -z $CONFIGPLUGIN ]; then
CONFIGPLUGIN="$arg"
verbose "Adding compiz plugin $arg to command line\n"
fi;
done
fi
}
####
# Execute checks, if necesarry.
function check_everything
{
if ! check_vesa_or_vga; then
check_nvidia
NVIDIA=$?
check_xgl
XGL=$?
check_fbconfig
FBCONFIG=$?
check_tfp
TFP=$?
check_npot_texture
NPOT=$?
check_composite
COMPOSITE=$?
check_xdamage
XDAMAGE=$?
check_xsync
XSYNC=$?
check_multiscreen
else
echo "Fatal: Compiz can't be ran using VESA or VGA divers."
exit 1;
fi
}
###
# Check if a directory exists; creates it if it doesn't, returns false if the
# path isn't a directory.
function require_dir
{
if ! [ -a "$1" ]; then
verbose "Creating directory $1\n";
mkdir $1;
fi
if [ ! -d $1 ]; then
echo "Warning: $1 exists but isn't a directory.";
return 1;
fi
return 0;
}
###
# Let's get this show started!
function start_compiz
{
if [ -n "$ENV" ]; then
verbose "Exporting: $ENV \n"
export $ENV
fi
if [ "x$DRY" = "xyes" ]; then exit 0; fi
if [ -n "$COMPIZRUNNING" ] && ! (echo $ARGS | grep -wq -- "--replace"); then
echo "Compiz is already running, you should use the --replace option to override it"
exit 0
elif [ -n "$WMRUNNING" ] && ! (echo $ARGS | grep -wq -- "--replace"); then
echo "There is already the $RUNNING_WIN_MANAGER win manager running, you should use the --replace option to override it"
exit 0
fi
if ! (run_command $COMPIZ $ARGS $PLUGINS); then
if [ -n "$FALLBACK_WINMANAGER" ]; then
if run_command $FALLBACK_WINMANAGER; then
exit 0;
else
echo "Fatal: Can't run $FALLBACK_WINMANAGER"
exit 1;
fi
else
echo "No fallback winmanager found/set"
fi
fi
}
####
# Starts one decorator per screen
function start_decorators
{
if ( [ -z "$DECORATOR" ] && [ -z "$RUNNING_COMPDECORATOR" ] ); then
case "$DE" in
KDE)
DECORATOR="kde-window-decorator"
DECORATORARGS="--replace"
;;
GNOME)
DECORATOR="gtk-window-decorator"
DECORATORARGS="--replace"
;;
*)
DECORATOR="gtk-window-decorator" #emerald?
DECORATORARGS="--replace"
;;
esac
fi
if [ -z "$(which $DECORATOR)" ]; then return 1; fi
if [ "$DECOERRORS" = "no" ]; then
OLDERROUTPUT="$ERROUTPUT"
ERROUTPUT="/dev/null"
fi
if [ "$SCREENS" == "1" ]; then
verbose "Starting delayed $DECORATOR in the background: "
verbose "sleeping $DELAY...\n"
if [ "x$DRY" = "xyes" ]; then return 0; fi
sleep $DELAY && \
run_command $DECORATOR $DECORATORARGS &
else
verbose "Starting delayed $DECORATOR for all screens: \n"
OLDDISPLAY="$DISPLAY"
for a in $SCREENNUMBERS; do
verbose "\t Screen $a: "
verbose "sleeping $DELAY...\n"
if [ "x$DRY" != "xyes" ]; then
sleep $DELAY && \
export DISPLAY=${MULTIDISPLAY[$a]} && \
run_command $DECORATOR $DECORATORARGS &
fi
done
export DISPLAY="$OLDDISPLAY"
fi
if [ "$DECOERRORS" = "no" ]; then
ERROUTPUT="$OLDERROUTPUT"
fi
}
function check_desktopmanager
{
if (pidof "startkde" &> /dev/null) ||
(pidof "kdeinit" &> /dev/null) ||
(pidof "klauncher" &> /dev/null) ||
(pidof "ksplash" &> /dev/null) ||
(pidof "start_kdeinit" &> /dev/null) ||
(kcheckrunning 2> /dev/null); then
DE="KDE"
DEFAULTDECORATOR="kwin"
DEFAULTDECORATORARGS="--replace"
elif (pidof "gnome-session" &> /dev/null) ||
(pidof "gnome-settings-daemon" &> /dev/null) ||
(pidof "gnome-panel" &> /dev/null); then
DE="GNOME"
DEFAULTDECORATOR="metacity"
DEFAULTDECORATORARGS="--replace"
elif pidof "xfce4-session" &> /dev/null; then
DE="Xfce"
DEFAULTDECORATOR="xfwm4"
DEFAULTDECORATORARGS=""
elif pidof "WindowMaker" &> /dev/null; then
DE="WindowMaker"
DEFAULTDECORATOR="wmaker"
DEFAULTDECORATORARGS=""
elif pidof "enlightenment_sys" &> /dev/null; then
DE="enlightenment"
DEFAULTDECORATOR="enlightenment"
DEFAULTDECORATORARGS=""
elif pidof "fbrun" &> /dev/null; then
DE="fluxbox"
DEFAULTDECORATOR="fluxbox"
DEFAULTDECORATORARGS=""
fi
if [ -n "$DE" ]; then
verbose "Found $DE desktop environment running...\n"
fi
}
function check_winmanager
{
STD_WMs="beryl compiz compiz.real metacity kwin xfwm4 wmaker fluxbox blackbox openbox icewm enlightenment"
for wm in $STD_WMs; do
if pidof $wm &> /dev/null; then
RUNNING_WIN_MANAGER="$wm"
break;
fi
done
if ! (xdpyinfo | grep -q "^focus:[ ]\+PointerRoot$"); then
WMRUNNING="true"
fi
STD_COMPDECORATORS="gtk-window-decorator kde-window-decorator emerald yald"
for deco in $STD_COMPDECORATORS; do
if pidof $deco &> /dev/null; then
RUNNING_COMPDECORATOR="$deco"
break;
fi
done
if [ -n "$RUNNING_WIN_MANAGER" ]; then
verbose "Found running windows manager: $RUNNING_WIN_MANAGER\n"
fi
if [ -n "$DE" ] && [ -z "$FALLBACK_WINMANAGER" ]; then
FALLBACK_WINMANAGER="$DEFAULTDECORATOR $DEFAULTDECORATORARG"
fi
if (echo $RUNNING_WIN_MANAGER | grep -qw "$(basename $COMPIZ)"); then #compiz\|compiz\.real
COMPIZRUNNING="true"
verbose "Compiz is already running in this environment\n"
else
unset COMPIZRUNNING
if [ -n "$RUNNING_WIN_MANAGER" ] && [ -z "$FALLBACK_WINMANAGER" ]; then
FALLBACK_WINMANAGER="$RUNNING_WIN_MANAGER" # --replace ?
fi
fi
if [ -n "$FALLBACK_WINMANAGER" ]; then
verbose "Setting fallback windows manager to $FALLBACK_WINMANAGER\n"
fi
}
function set_config_plugin
{
if ( [ -n "$CONFIGPLUGIN" ] && [ -f "$COMPIZPLUGINDIR/lib${CONFIGPLUGIN}.so" ] ); then
verbose "Loading the $CONFIGPLUGIN settings interface\n"
else
for plugin in $CONFIGPLUGINS; do
if [ -f "$COMPIZPLUGINDIR/lib${plugin}.so" ]; then
CONFIGPLUGIN="$plugin"
verbose "Loading the $plugin settings interface\n"
break;
fi
done
fi
if [ "$CONFIGPLUGIN" = "gconf" ]; then
PLUGINS=${PLUGINS//glib/}
CONFIGPLUGIN="glib gconf"
fi
# if [ "$CONFIGPLUGIN" = "ccp" ]; then
# # Set default compizconfig configuration; disabled by default
# set_default_ccs
# fi
PLUGINS="$CONFIGPLUGIN $PLUGINS"
}
function set_default_ccs
{
# Not needed if is set a proper global.xml file in libcompizconfig
CCSDEFCONFIG="~/.compizconfig/Default.ini"
if [ ! -f "$CCSDEFCONFIG" ]; then
mkdir -p $CCSDEFCONFIG
touch "$CCSDEFCONFIG"
fi
if ! (grep -q "as_____plugin_enabled" $CCSDEFCONFIG); then
for plugin in $DEFAULTCCSPLUGINS; do
echo "[$plugin]" > $CCSDEFCONFIG
echo "as_____plugin_enabled = true" > $CCSDEFCONFIG
echo "" > $CCSDEFCONFIG
done
fi
}
function run_command
{
verbose Executing: "$*" "\n"
if [ -n "$STDOUTPUT" ] && [ -n "$ERROUTPUT" ]; then
$* 1>> $STDOUTPUT 2>> $ERROUTPUT
elif [ -n "$STDOUTPUT" ] && [ -z "$ERROUTPUT" ]; then
$* 1>> $STDOUTPUT
elif [ -z "$STDOUTPUT" ] && [ -n "$ERROUTPUT" ]; then
$* 2>> $ERROUTPUT
else
$*
fi
return $?
}
####################
# Execution begins here.
# First get options, check for configuration
# Check everything if necesarry, build the enviroment and arguments
# and eventually select a task.
parse_options $*
if [ -z "$NOCHECKS" ]; then check_everything; fi
###
# This is the master-test, it has to be done last.
if [ -z "$POSSIBLE" ]; then check_possible
else verbose "Skipping \"possible\" test, using stored value.\n"; fi
# No need to continue if we've determined it's not possible to start anyway
if [ $POSSIBLE != "0" ]; then
echo "Checks indicate that it's impossible to start compiz on your system."
exit 1;
else
verbose "Checks indicate compiz should work on your system\n"
fi
####
# Builds the enviromental variables list and argument list based
# on the result of the checks
build_env
build_args
check_desktopmanager
check_winmanager
case "$TASK" in
RECOMMEND)
if [ "x$REC" = "xenv" ]; then
echo -e $ENV;
elif [ "x$REC" = "xargs" ]; then
echo -e $ARGS
elif [ "x$REC" = "xboth" ]; then
echo -e $ARGS $PLUGINS
echo -e $ENV
fi
if [ $POSSIBLE != "0" ]; then return 1; fi
;;
WINDOWDECORATOR)
start_decorators
;;
*)
start_decorators
set_config_plugin
start_compiz
;;
esac