#!/usr/bin/env python
# Author(s): crdlb
import ConfigParser, compizconfig
from os import system, environ, path, popen, mkdir
from subprocess import Popen
from commands import getoutput

# Defining functions

def create_config_file():
        default_config = open(config_file, 'w')
        default_config.write('# Config file for fusion-icon\n')
        default_config.write('\n')
        default_config.write('[window_manager]\n')
        default_config.write('active_wm = compiz\n')
        default_config.write('\n')
        default_config.write('[compiz_options]\n')
        default_config.write('fast_filter = \n')
        default_config.write('indirect_rendering = \n')
        default_config.write('loose_binding = \n')
        default_config.close()

def installed(app):
        global app_is_installed
        return app in app_is_installed

def default_decorator():
        if installed('kde-window-decorator') and kde and not gnome:
                decorator = 'kde-window-decorator --replace'
        elif installed('gtk-window-decorator') and gnome and not kde:
                decorator = 'gtk-window-decorator --replace'
        elif  installed('emerald'):
                decorator = 'emerald --replace'
        elif installed('gtk-window-decorator'):
                decorator = 'gtk-window-decorator --replace'
        elif installed('kde-window-decorator'):
                decorator = 'kde-window-decorator --replace'
        else:
                decorator = ''
        print '* choosing ', decorator, ' as default decorator'
        return decorator

def fallback_wm():
        if installed('kwin') and kde and not gnome:
                configuration.set('window_manager', 'active_wm', 'kwin')
        elif installed('metacity') and gnome and not kde:
                configuration.set('window_manager', 'active_wm', 'metacity')
        else:
                configuration.set('window_manager', 'active_wm', '')

def env_intel():
        if not getoutput('xvinfo 2>/dev/null|grep Intel') == '':
                print '* intel found, exporting: INTEL_BATCH=1'
                return 'INTEL_BATCH=1 '

def is_always_indirect():
        if int(getoutput('glxinfo 2>/dev/null | grep GLX_EXT_texture_from_pixmap -c')) < 3:
                if int(getoutput('LIBGL_ALWAYS_INDIRECT=1 glxinfo 2>/dev/null | grep GLX_EXT_texture_from_pixmap -c')) == 3:
                        return True

def env_indirect():
        if is_always_indirect():
                print '* No GLX_EXT_texture_from_pixmap present with direct rendering context'
                print '... present with indirect rendering, exporting: LIBGL_ALWAYS_INDIRECT=1'
                return 'LIBGL_ALWAYS_INDIRECT=1 '
        else: return "" 

def env_fglrx():
        if path.exists('/usr/lib/fglrx/libGL.so.1.2.xlibmesa'):
                print '* fglrx found, exporting: LD_PRELOAD=/usr/lib/fglrx/libGL.so.1.2.xlibmesa'
                return 'LD_PRELOAD=/usr/lib/fglrx/libGL.so.1.2.xlibmesa '
        else: return ""

def env_nvidia():
        if not getoutput('xdpyinfo 2>/dev/null|grep NV-GLX') == '':
                print '* nvidia found, exporting: __GL_YIELD=nothing '
                return '__GL_YIELD=nothing '
        else: return ""

def get_env():
        return env_intel() + env_indirect() + env_fglrx() + env_nvidia()

def start_wm(active_wm):
        if active_wm == compiz:
                start_compiz()
        else:
                run_wm = active_wm + ' --replace'
                Popen(run_wm, shell=True)

def start_compiz():
        # Get Env Variables                                                                                          
        env_variables = get_env()
        # Compiz Options
        fast_filter = configuration.get('compiz_options', 'fast_filter')
        indirect_rendering = configuration.get('compiz_options', 'indirect_rendering')
        loose_binding = configuration.get('compiz_options', 'loose_binding')
        # Start Compiz WM
        system('killall gtk-window-decorator kde-window-decorator emerald')
        if not decoplugin.Enabled:
                context.ProcessEvents()
                decoplugin.Enabled = True
                decoplugin.Update()
                context.Write()
        #sleep(2)
        run_compiz = env_variables + compiz + ' --replace --sm-disable --ignore-desktop-hints ccp ' + fast_filter + ' ' + indirect_rendering + ' ' + loose_binding
        print run_compiz
        Popen(run_compiz, shell=True)

def pre_start_wm():
        active_wm = configuration.get('window_manager', 'active_wm')
        #make sure not to start compiz if not installed.
        if compiz != '':
                start_wm(active_wm)
        else:
                fallback_wm()
                start_wm(active_wm)

def set_decorator(decorator):
        if initialized or first_set:
                context.ProcessEvents()
                decosetting.Value = decorator
                print '* setting decorator to', decosetting.Value
                decoplugin.Update()
                context.Write()

def get_decorator():
        if decosetting.Value != '':
                decorator = decosetting.Value
        else:
                decorator = default_decorator()
        return decorator

def etm_menu_activate(widget):
        Popen(['emerald-theme-manager'])

def wm_activate(widget):
        if initialized:
                print '* reloading window manager...'
                pre_start_wm()

def compiz_menu_activate(widget):
        # Set compiz wm
        configuration.set('window_manager', 'active_wm', compiz)
        configuration.write(open(config_file, 'w'))
        if initialized and compiz_wm.active:
                print '* switching to Compiz...'
                pre_start_wm()

def kwin_menu_activate(widget):
        # Set kwin wm
        configuration.set('window_manager', 'active_wm', 'kwin')
        configuration.write(open(config_file, 'w'))
        if initialized and kwin_wm.active:
                print '* switching to Kwin...'
                pre_start_wm()

def metacity_menu_activate(widget):
        # Set metacity wm
        configuration.set('window_manager', 'active_wm', 'metacity')
        configuration.write(open(config_file, 'w'))
        if initialized and metacity_wm.active:
                print '* switching to Metacity...'
                pre_start_wm()

def xfwm4_menu_activate(widget):
        # Set Xfwm4 wm
        configuration.set('window_manager', 'active_wm', 'xfwm4')
        configuration.write(open(config_file, 'w'))
        if initialized and metacity_wm.active:
                print '* switching to Xfwm4...'
                pre_start_wm()

initialized = False
first_set = False
always_indirect = is_always_indirect()

#Open CompizConfig context
context = compizconfig.Context()
decoplugin = context.Plugins['decoration']
decosetting = compizconfig.Setting(decoplugin, 'command', 0)

# Get installed applications
app_is_installed = []
apps = ('compiz.real', 'compiz' , 'ccsm' , 'gtk-window-decorator', 'kde-window-decorator', 'emerald' , 'metacity' , 'kwin', 'xfwm4')
for application in apps:
        if system('which ' + application) == 0:
                app_is_installed.append(application)

compiz = ''
if installed('compiz.real'): compiz = 'compiz.real'
elif installed('compiz'): compiz = 'compiz'

# Check whether GNOME or KDE running
kde = gnome = False
if system('pgrep gnome-session') == 0: gnome = True
if system('pgrep dcop') == 0: kde = True

print 'gnome is', gnome, ', kde is', kde



active_decorator = get_decorator()
first_set = True
set_decorator(active_decorator)
first_set = False

# Variables
home = environ.get('HOME')
config_folder = environ.get('XDG_CONFIG_HOME', path.join(home, '.config'))
config_file = path.join(config_folder, 'fusion-icon')
pixmap_dir = '/usr/share/pixmaps'

# Configuration file setup
if not path.exists(config_folder):
        mkdir(config_folder)
        create_config_file()
elif not path.exists(config_file):
        create_config_file()

# Retrieve configuration from ~/.config/fusion-icon
configuration = ConfigParser.ConfigParser()
configuration.read(config_file)
active_wm = configuration.get('window_manager', 'active_wm')
fast_filter = configuration.get('compiz_options', 'fast_filter')
indirect_rendering = configuration.get('compiz_options', 'indirect_rendering')
loose_binding = configuration.get('compiz_options', 'loose_binding')