#!/usr/bin/env python
# Author(s): Keeguon, crdlb
import ConfigParser, gobject, pygtk, gtk, compizconfig
pygtk.require('2.0')
from commands import getoutput
from os import mkdir, system, popen, path, environ
from subprocess import Popen
from time import sleep

# Defining functions
def installed(app):
	global app_is_installed
	return app in app_is_installed

def default_decorator():
	global decorator
	if installed('kde-window-decorator') and kde and not gnome:
		decorator = 'kde-window-decorator'
	elif installed('gtk-window-decorator') and gnome and not kde:
		decorator = 'gtk-window-decorator'
	elif  installed('emerald'):
		decorator = 'emerald'
	elif installed('gtk-window-decorator'):
		decorator = 'gtk-window-decorator'	
	elif installed('kde-window-decorator'):
		decorator = 'kde-window-decorator'
	else:
		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 create_config_file():
	
	set_decorator(default_decorator())
	default_config = open(config_file, 'w')
	default_config.write('# Config file for compiz-fusion-icon (generated with python)\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 get_env():
	IB = LIGLAI = LDPL = GLYN = ''
	print getoutput('glxinfo 2>/dev/null | grep GLX_EXT_texture_from_pixmap -c')
	if int(getoutput('glxinfo 2>/dev/null | grep GLX_EXT_texture_from_pixmap -c')) < 3:
		print '* No GLX_EXT_texture_from_pixmap present with direct rendering context'
		if int(getoutput('LIBGL_ALWAYS_INDIRECT=1 glxinfo 2>/dev/null | grep GLX_EXT_texture_from_pixmap -c')) == 3:
			print '... present with indirect rendering, exporting: LIBGL_ALWAYS_INDIRECT=1'
			LIGLAI = 'LIBGL_ALWAYS_INDIRECT=1'	
	if not int(getoutput('xdpyinfo 2>/dev/null|grep NV-GLX -c')) == 0:
		print '* nvidia found, exporting: __GL_YIELD=nothing'
		GLYN = '__GL_YIELD=nothing'
	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'
		LDPL = 'LD_PRELOAD=/usr/lib/fglrx/libGL.so.1.2.xlibmesa'
	if not getoutput('xvinfo 2>/dev/null|grep Intel') == '':
		print '* intel found, exporting: INTEL_BATCH=1'
		IB = 'INTEL_BATCH=1'
	env = IB + LIGLAI + LDPL + GLYN
	return env

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

	
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')
	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)
	print 'started', compiz


def pre_start_wm():
	active_wm = configuration.get('window_manager', 'active_wm')
	print 'compiz is', compiz
	print 'activewm is', 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:
		context.ProcessEvents()
		decosetting.Value = decorator
		print "* setting decorator to", decosetting.Value	
		decoplugin.Update()
		context.Write()
		
def get_decorator():

	active_decorator = decosetting.Value
	return active_decorator
	
# Compiz-Manager Menu Functions
def popup_menu(widget, button, time, data = None):
	if button == 3 and data:
		data.show_all()
		data.popup(None, None, gtk.status_icon_position_menu, 3, time, icon)

def configure_menu_activate(widget):
	gobject.spawn_async(['ccsm'], flags=gobject.SPAWN_SEARCH_PATH)

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
	print "active (and old) wm is", active_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
	print "active (and old) wm is", active_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
	print "active (and old) wm is", active_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 option_ff_activate(widget):
	# Set/Unset ff option
	if option_ff.get_active():
		configuration.set('compiz_options', 'fast_filter', '--fast-filter')
		configuration.write(open(config_file, 'w'))
	else:
		configuration.set('compiz_options', 'fast_filter', '')
		configuration.write(open(config_file, 'w'))
	if active_wm == compiz and initialized:
		start_compiz()
		
def option_ir_activate(widget):
	# Set/Unset ir option
	if option_ir.get_active():
		configuration.set('compiz_options', 'indirect_rendering', '--indirect-rendering')
		configuration.write(open(config_file, 'w'))
	else:
		configuration.set('compiz_options', 'indirect_rendering', '')
		configuration.write(open(config_file, 'w'))
	if active_wm == compiz and initialized:
		start_compiz()
		
def option_lb_activate(widget):
	# Set/Unset lb option
	if option_lb.get_active():
		configuration.set('compiz_options', 'loose_binding', '--loose-binding')
		configuration.write(open(config_file, 'w'))
	else:
		configuration.set('compiz_options', 'loose_binding', '')
		configuration.write(open(config_file, 'w'))
	if active_wm == compiz and initialized:
		start_compiz()

def emerald_menu_activate(widget):
	if initialized and emerald_decorator.active:
		if active_wm == compiz and get_decorator() != 'emerald --replace':
			#remove the "--replace" (and any other arguments)
			old_dec_list = get_decorator().split()
			old_decorator = old_dec_list[0]
			system('killall %s' % (old_decorator))
			sleep(1)
		set_decorator('emerald --replace')

def kwd_menu_activate(widget):
	if initialized and kwd_decorator.active:
		if active_wm == compiz and get_decorator() != 'kde-window-decorator --replace':
			old_dec_list = get_decorator().split()
			old_decorator = old_dec_list[0]
			system('killall %s' % (old_decorator))
			sleep(1)
		set_decorator('kde-window-decorator --replace')
		
def gwd_menu_activate(widget): 
	if initialized and gwd_decorator.active:
		if active_wm == compiz and get_decorator() != 'gtk-window-decorator --replace':
			old_dec_list = get_decorator().split()
			old_decorator = old_dec_list[0]
			system('killall %s' % (old_decorator))
			sleep(1)
		set_decorator('gtk-window-decorator --replace')

def quit_menu_activate(widget):
	gtk.main_quit()

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


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

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

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

#Initialize Compizconfig

active_decorator = get_decorator()

# Variables
user = getoutput('whoami')
home = '/home/' + user + '/'
config_folder = environ.get('XDG_CONFIG_HOME', path.join(home, '.config'))  
config_file = config_folder + '/compiz-fusion-icon.conf'
pixmap_dir = '/usr/share/pixmaps/compiz-icon/'

# Home directory related stuffs
if not path.exists(config_folder):
	mkdir(config_folder)
	create_config_file()
if path.exists(config_folder) and not path.exists(config_file):
	create_config_file()

# Retrieve configuration from compiz-fusion-icon.conf
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')



# Window Manager
wm_menu = gtk.Menu()
compiz_wm = gtk.RadioMenuItem(label=' Compiz')
compiz_wm.connect('activate', compiz_menu_activate)
if active_wm == compiz:
	compiz_wm.set_active(True)
if compiz == '':
	compiz_wm.set_sensitive(False)
wm_menu.append(compiz_wm)
kwin_wm = gtk.RadioMenuItem(label=' Kwin')
kwin_wm.set_group(compiz_wm)
kwin_wm.connect('activate', kwin_menu_activate)
if active_wm == 'kwin':
	kwin_wm.set_active(True)
if not installed('kwin'):
	kwin_wm.set_sensitive(False)
wm_menu.append(kwin_wm)
metacity_wm = gtk.RadioMenuItem(label=' Metacity')
metacity_wm.set_group(compiz_wm)
metacity_wm.connect('activate', metacity_menu_activate)
if active_wm == 'metacity':
	metacity_wm.set_active(True)
if not installed('metacity'):
	metacity_wm.set_sensitive(False)
wm_menu.append(metacity_wm)

# Compiz Options
options_menu = gtk.Menu()
option_ff = gtk.CheckMenuItem(label=' Fast Filter')
option_ff.connect('activate', option_ff_activate)
if fast_filter == '--fast-filter':
	option_ff.set_active(True)
options_menu.append(option_ff)
option_ir = gtk.CheckMenuItem(label=' Indirect Rendering')
option_ir.connect('activate', option_ir_activate)
if indirect_rendering == '--indirect-rendering':
	option_ir.set_active(True)
options_menu.append(option_ir)
option_lb = gtk.CheckMenuItem(label=' Loose Binding')
option_lb.connect('activate', option_lb_activate)
if loose_binding == '--loose-binding':
	option_lb.set_active(True)
options_menu.append(option_lb)

# Window Decorator
decorator_menu = gtk.Menu()
emerald_decorator = gtk.RadioMenuItem(label=' Emerald')
emerald_decorator.connect('activate', emerald_menu_activate)
if active_decorator == 'emerald --replace':
	emerald_decorator.set_active(True)
if not installed('emerald'):
	emerald_decorator.set_sensitive(False)
decorator_menu.append(emerald_decorator)

gwd_decorator = gtk.RadioMenuItem(label=' GTK Window Decorator')
gwd_decorator.set_group(emerald_decorator)
gwd_decorator.connect('activate', gwd_menu_activate)
if active_decorator == 'gtk-window-decorator --replace':
	gwd_decorator.set_active(True)
if not installed('gtk-window-decorator'):
	gwd_decorator.set_sensitive(False)
decorator_menu.append(gwd_decorator)

kwd_decorator = gtk.RadioMenuItem(label=' KDE Window Decorator')
kwd_decorator.set_group(emerald_decorator)
kwd_decorator.connect('activate', kwd_menu_activate)
if active_decorator == 'kde-window-decorator --replace':
	kwd_decorator.set_active(True)
if not installed('kde-window-decorator'):
	kwd_decorator.set_sensitive(False)
decorator_menu.append(kwd_decorator)

# Compiz-Manager Tray Menu		
menu = gtk.Menu()
item = gtk.ImageMenuItem('Settings Manager')
img_sm = gtk.Image()
img_sm.set_from_stock('gtk-preferences', gtk.ICON_SIZE_MENU)
item.set_image(img_sm)
item.connect('activate', configure_menu_activate)
menu.append(item)
item = gtk.ImageMenuItem('Emerald Theme Manager')
if not installed('emerald'):
	item.set_sensitive(False)
item.connect('activate', etm_menu_activate)
img_etm = gtk.Image()
img_etm.set_from_icon_name('emerald-theme-manager-icon', gtk.ICON_SIZE_MENU)
item.set_image(img_etm)
menu.append(item)
item = gtk.SeparatorMenuItem()
menu.append(item)

# Window Manager Options
item = gtk.ImageMenuItem('Reload Window Manager')
item.connect('activate', wm_activate)
img_refresh = gtk.Image()
img_refresh.set_from_stock('gtk-refresh', gtk.ICON_SIZE_MENU)
item.set_image(img_refresh)
menu.append(item)
item = gtk.ImageMenuItem('Select Window Manager')
gtk.MenuItem.set_submenu(item, wm_menu)
img_wm = gtk.Image()
img_wm.set_from_stock('gtk-index', gtk.ICON_SIZE_MENU)
item.set_image(img_wm)
menu.append(item)
item = gtk.ImageMenuItem('Compiz Options')
gtk.MenuItem.set_submenu(item, options_menu)
img_options = gtk.Image()
img_options.set_from_stock('gtk-properties', gtk.ICON_SIZE_MENU)
item.set_image(img_options)
menu.append(item)
item = gtk.ImageMenuItem('Select Window Decorator')
gtk.MenuItem.set_submenu(item, decorator_menu)
img_wd = gtk.Image()
img_wd.set_from_stock('gtk-select-color', gtk.ICON_SIZE_MENU)
item.set_image(img_wd)
menu.append(item)

item = gtk.SeparatorMenuItem()
menu.append(item)
item = gtk.ImageMenuItem(stock_id=gtk.STOCK_QUIT)
item.connect('activate', quit_menu_activate)
menu.append(item)
menu.show_all()

# Compiz-Manager Tray Icon
pixbuf = gtk.gdk.pixbuf_new_from_file(pixmap_dir + 'tray-icon.svg')
icon = gtk.StatusIcon()
icon.set_from_pixbuf(pixbuf)
icon.set_tooltip('Compiz Fusion Icon')
icon.connect('popup-menu', popup_menu, menu)

initialized = True
#start a WM
pre_start_wm()
# Compiz-Manager Main
gtk.main()