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

# 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 == True and gnome == False:
		decorator = 'kde-window-decorator'
	if installed('gtk-window-decorator') and gnome == True and kde == False:
		decorator = 'gtk-window-decorator'
	if  installed('emerald') and kde == gnome == True:
		decorator = 'emerald'
	if  installed('emerald') and kde == gnome == False:
		decorator = 'emerald'

def fallback_wm():
	configuration = ConfigParser.ConfigParser()
	configuration.read(config_file)
	if installed('kwin') and kde == True and gnome == False:
		configuration.set('window_manager', 'set_active_wm', 'kwin')
	if installed('metacity') and gnome == True and kde == False:
		configuration.set('window_manager', 'set_active_wm', 'metacity')

def create_config_file():
	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('set_active_wm = compiz\n')
	default_config.write('wm_replace = --replace\n')
	default_config.write('\n')
	default_config.write('[default_compiz_options]\n')
	default_config.write('sm_disable = --sm-disable\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.write('\n')
	default_config.write('[decorator]\n')
	default_config.write('set_active_decorator = ' + decorator + '\n')
	default_config.write('decorator_replace= --replace')
	default_config.close()

def activate_config_ini():
	# Retrieve configuration from the INI file
	configuration = ConfigParser.ConfigParser()
	configuration.read(config_file)
	# Window Manager
	active_wm = configuration.get('window_manager', 'set_active_wm')
	if active_wm == 'compiz':
		# Get Env Variables
		env_variables = getoutput('compiz-manager -ir env')
		# Compiz Options
		wm_replace = configuration.get('window_manager', 'wm_replace')
		sm_disable = configuration.get('default_compiz_options', 'sm_disable')
		fast_filter = configuration.get('compiz_options', 'fast_filter')
		indirect_rendering = configuration.get('compiz_options', 'indirect_rendering')
		loose_binding = configuration.get('compiz_options', 'loose_binding')
		# Decorator
		set_active_decorator = configuration.get('decorator', 'set_active_decorator')
		decorator_replace = configuration.get('decorator', 'decorator_replace')
		# Start Compiz WM
		Popen(['killall' , compiz, 'metacity' , 'kwin'])
		run_compiz = env_variables + ' ' + compiz + ' ' + wm_replace + ' ' + sm_disable + ' ' + fast_filter + ' ' + indirect_rendering + ' ' + loose_binding + ' ' + 'ccp'
		Popen(run_compiz, shell=True)
		# Start Decorator
		Popen(['killall' , 'gtk-window-decorator' , 'kde-window-decorator' , 'emerald'])
		Popen(set_active_decorator + ' ' + decorator_replace, shell=True)
	if active_wm == 'metacity':
		wm_replace = configuration.get('window_manager', 'wm_replace')
		# Start Metacity WM
		Popen(['killall' , compiz, 'gtk-window-decorator' , 'kde-window-decorator' , 'emerald' , 'metacity' , 'kwin'])
		Popen(['metacity' , wm_replace])
	if active_wm == 'kwin':
		wm_replace = configuration.get('window_manager', 'wm_replace')
		# Start Kwin WM
		Popen(['killall' , compiz, 'gtk-window-decorator' , 'kde-window-decorator' , 'emerald' , 'metacity' , 'kwin'])
		Popen(['kwin' , wm_replace])

def activate_compiz_manager():
	if compiz != "":
		activate_config_ini()
	else:
		fallback_wm()
		activate_config_ini()

# Compiz-Manager Menu Functions
def popup_menu(widget, button, time, data = None):
	if button == 3:
		if data:
			data.show_all()
			data.popup(None, None, None, 3, time)
	pass

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

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

def start_wm(widget):
	if installed('compiz'):
		activate_config_ini()
	else:
		fallback_wm()
		activate_config_ini()

def compiz_menu_activate(widget):
	# Get Env Variables
	env_variables = getoutput('compiz-manager -ir env')
	# Set compiz wm
	configuration.set('window_manager', 'set_active_wm', 'compiz')
	configuration.write(open(config_file, 'w'))
	# Get compiz wm
	set_active_wm = configuration.get('window_manager', 'set_active_wm')
	wm_replace = configuration.get('window_manager', 'wm_replace')
	# Get compiz options
	sm_disable = configuration.get('default_compiz_options', 'sm_disable')
	fast_filter = configuration.get('compiz_options', 'fast_filter')
	indirect_rendering = configuration.get('compiz_options', 'indirect_rendering')
	loose_binding = configuration.get('compiz_options', 'loose_binding')
	# Get gl decorator
	set_active_decorator = configuration.get('decorator', 'set_active_decorator')
	decorator_replace = configuration.get('decorator', 'decorator_replace')
	# Run compiz
	Popen(['killall' , compiz, 'metacity' , 'kwin'])
	run_compiz = env_variables + ' ' + compiz + ' ' + wm_replace + ' ' + sm_disable + ' ' + fast_filter + ' ' + indirect_rendering + ' ' + loose_binding + ' ' + 'ccp'
	Popen(run_compiz, shell=True)
	# Start Decorator
	Popen(['killall' , 'gtk-window-decorator' , 'kde-window-decorator' , 'emerald'])
	Popen(set_active_decorator + ' ' + decorator_replace, shell=True)

def kwin_menu_activate(widget):
	# Set kwin wm
	configuration.set('window_manager', 'set_active_wm', 'kwin')
	configuration.write(open(config_file, 'w'))
	# Get kwin wm
	set_active_wm = configuration.get('window_manager', 'set_active_wm')
	wm_replace = configuration.get('window_manager', 'wm_replace')
	# Run kwin
	Popen(['killall' , compiz, 'gtk-window-decorator' , 'kde-window-decorator' , 'emerald' , 'metacity' , 'kwin'])
	Popen([set_active_wm , wm_replace])

def metacity_menu_activate(widget):
	# Set metacity wm
	configuration.set('window_manager', 'set_active_wm', 'metacity')
	configuration.write(open(config_file, 'w'))
	# Get metacity wm
	set_active_wm = configuration.get('window_manager', 'set_active_wm')
	wm_replace = configuration.get('window_manager', 'wm_replace')
	# Run metacity
	Popen(['killall' , compiz, 'gtk-window-decorator' , 'kde-window-decorator' , 'emerald' , 'metacity' , 'kwin'])
	Popen([set_active_wm , wm_replace])

def option_ff_activate(widget):
	# Set/Unset ff option
	if option_ff.get_active() == True:
		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'))

def option_ir_activate(widget):
	# Set/Unset ir option
	if option_ir.get_active() == True:
		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'))

def option_lb_activate(widget):
	# Set/Unset lb option
	if option_lb.get_active() == True:
		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'))

def start_decorator(widget):
	# Get decorator
	set_active_decorator = configuration.get('decorator', 'set_active_decorator')
	decorator_replace = configuration.get('decorator', 'decorator_replace')
	# Run decorator
	Popen(['killall' , 'gtk-window-decorator' , 'kde-window-decorator' , 'emerald' , 'metacity' , 'kwin'])
	Popen([set_active_decorator , decorator_replace])

def emerald_menu_activate(widget):
	# Set emerald decorator
	configuration.set('decorator', 'set_active_decorator', 'emerald')
	configuration.write(open(config_file, 'w'))
	# Get emerald decorator
	set_active_decorator = configuration.get('decorator', 'set_active_decorator')
	decorator_replace = configuration.get('decorator', 'decorator_replace')
	# Run emerald
	Popen(['killall' , 'gtk-window-decorator' , 'kde-window-decorator' , 'emerald'])
	Popen([set_active_decorator , decorator_replace])

def kwd_menu_activate(widget):
	# Set kwd decorator
	configuration.set('decorator', 'set_active_decorator', 'kde-window-decorator')
	configuration.write(open(config_file, 'w'))
	# Get kwd decorator
	set_active_decorator = configuration.get('decorator', 'set_active_decorator')
	decorator_replace = configuration.get('decorator', 'decorator_replace')
	# Run kwd
	Popen(['killall' , 'gtk-window-decorator' , 'kde-window-decorator' , 'emerald'])
	Popen([set_active_decorator , decorator_replace])

def gwd_menu_activate(widget):
	# Set gwd decorator
	configuration.set('decorator', 'set_active_decorator', 'gtk-window-decorator')
	configuration.write(open(config_file, 'w'))
	# Get gwd decorator
	set_active_decorator = configuration.get('decorator', 'set_active_decorator')
	decorator_replace = configuration.get('decorator', 'decorator_replace')
	# Run gwd
	Popen(['killall' , 'gtk-window-decorator' , 'kde-window-decorator' , 'emerald'])
	Popen([set_active_decorator , decorator_replace])
	
def about_window(widget):
	# About Window
	about_window = gtk.Window(type=gtk.WINDOW_TOPLEVEL)
	about_window.set_title('About - Compiz Fusion Icon')
	about_window.set_default_size(400, 227)
	about_window.set_position(gtk.WIN_POS_CENTER)

	# Vbox
	vbox = gtk.VBox(False, 0)
	about_window.add(vbox)

	# Compiz Logo
	compiz_logo = gtk.Image()
	compiz_logo.set_from_file(pixmap_dir + 'about.png')

	# Title Text
	title_text = gtk.Label()
	title_text.set_markup(
	'<span size="xx-large"><b>Compiz Fusion Icon v0.1</b></span>'
	)
	title_text.set_justify(gtk.JUSTIFY_CENTER)

	# Undertitle Text
	undertitle_text = gtk.Label()
	undertitle_text.set_markup(
	'User-friendly launcher for Compiz Fusion\n'
	)
	undertitle_text.set_justify(gtk.JUSTIFY_CENTER)

	# Author Text
	author_text = gtk.Label()
	author_text.set_markup(
	'<small>Copyleft - 2007 - F. Bellanger</small>'
	)
	undertitle_text.set_justify(gtk.JUSTIFY_CENTER)

	# Buttons
	hbox_buttons = gtk.HBox(False, 0)

	credits_button = gtk.Button(' _Credits', use_underline=True)
	credits_image = gtk.Image()
	credits_image.set_from_stock(gtk.STOCK_ABOUT, gtk.ICON_SIZE_BUTTON)
	credits_button.set_image(credits_image)
	credits_button.connect("clicked", credits_window)
	quit_button = gtk.Button(stock=gtk.STOCK_CLOSE)
	quit_button.connect("clicked", lambda x: about_window.destroy())
	quit_alignment = gtk.Alignment(1, 0, 0, 0)
	quit_alignment.add(quit_button)

	hbox_buttons.pack_start(credits_button, False, False, 5)
	hbox_buttons.pack_start(quit_alignment, True, True, 5)

	# Adding elements to the Vbox
	vbox.pack_start(compiz_logo, False, False, 5)
	vbox.pack_start(title_text, False, False, 5)
	vbox.pack_start(undertitle_text, False, False, 5)
	vbox.pack_start(author_text, False, False, 5)
	vbox.pack_start(hbox_buttons, False, False, 5)

	about_window.show_all()

def credits_window(widget):
	# Credits Window
	credits_window = gtk.Window(type=gtk.WINDOW_TOPLEVEL)
	credits_window.set_title('Credits - Compiz Icon')
	credits_window.set_default_size(350, 275)
	credits_window.set_position(gtk.WIN_POS_CENTER)

	# Vbox for Credits Window
	vbox_credits = gtk.VBox(False, 0)
	credits_window.add(vbox_credits)

	# Written by tab
	writtenby_frame = gtk.Frame()
	writtenby_frame.set_shadow_type(gtk.SHADOW_OUT)
	writtenby_textarea = gtk.TextView()
	writtenby_textarea.set_editable(False)
	writtenby_textarea.set_size_request(0, 185)
	writtenby_buffer = writtenby_textarea.get_buffer()
	writtenby_buffer.set_text('Felix Bellanger <keeguon@gmail.com>')
	activate_scroll = gtk.ScrolledWindow()
	activate_scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
	activate_scroll.add(writtenby_textarea)
	writtenby_frame.add(activate_scroll)

	# Set Tab box
	writtenby_label = gtk.Label('Written by')
	tab_box = gtk.Notebook()
	tab_box.append_page(writtenby_frame, tab_label=writtenby_label)

	# Close button
	close_button = gtk.Button(stock=gtk.STOCK_CLOSE)
	close_button.connect("clicked", lambda x: credits_window.destroy())
	close_alignment = gtk.Alignment(1, 0, 0, 0)
	close_alignment.add(close_button)

	# Append elements to Credits Window via Vbox
	vbox_credits.pack_start(tab_box, False, True, 10)
	vbox_credits.pack_start(close_alignment, False, True, 0)

	# Show Credits Window
	credits_window.show_all()

def quit_menu_activate(widget):
	gtk.main_quit()

# 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)

compiz = ""
if installed('compiz.real'):
	compiz = 'compiz.real'
else:
	compiz = 'compiz'

# Get default Decorator
default_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 path.exists(config_folder) == False:
	# Create home directory
	mkdir(config_folder)
	# Create and Write the default config_file
	create_config_file()
if path.exists(config_folder) == True and path.exists(config_file) == False:
	# Create and Write the default config_file
	create_config_file()

# Retrieve configuration from compiz-icon.conf
configuration = ConfigParser.ConfigParser()
configuration.read(config_file)
# WM
set_active_wm = configuration.get('window_manager', 'set_active_wm')
# Decorator
set_active_decorator = configuration.get('decorator', 'set_active_decorator')
# 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')

# Window Manager
wm_menu = gtk.Menu()
if compiz != "":
	compiz_wm = gtk.RadioMenuItem(label=" Compiz")
	compiz_wm.connect("activate", compiz_menu_activate)
	if set_active_wm == 'compiz':
		compiz_wm.set_active(True)
	wm_menu.append(compiz_wm)
if installed('kwin'):
	kwin_wm = gtk.RadioMenuItem(label=" Kwin")
	kwin_wm.set_group(compiz_wm)
	kwin_wm.connect("activate", kwin_menu_activate)
	if set_active_wm == 'kwin':
		kwin_wm.set_active(True)
	wm_menu.append(kwin_wm)
if installed('metacity'):
	metacity_wm = gtk.RadioMenuItem(label=" Metacity")
	metacity_wm.set_group(compiz_wm)
	metacity_wm.connect("activate", metacity_menu_activate)
	if set_active_wm == 'metacity':
		metacity_wm.set_active(True)
	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()
if installed('emerald'):
	emerald_decorator = gtk.RadioMenuItem(label=" Emerald")
	emerald_decorator.connect("activate", emerald_menu_activate)
	if set_active_decorator == 'emerald':
		emerald_decorator.set_active(True)
	decorator_menu.append(emerald_decorator)
if installed('kde-window-decorator'):
	kwd_decorator = gtk.RadioMenuItem(label=" KDE Window Decorator")
	kwd_decorator.set_group(emerald_decorator)
	kwd_decorator.connect("activate", kwd_menu_activate)
	if set_active_decorator == 'kde-window-decorator':
		kwd_decorator.set_active(True)
	decorator_menu.append(kwd_decorator)
if installed('gtk-window-decorator'):
	gwd_decorator = gtk.RadioMenuItem(label=" GTK Window Decorator")
	gwd_decorator.set_group(emerald_decorator)
	gwd_decorator.connect("activate", gwd_menu_activate)
	if set_active_decorator == 'gtk-window-decorator':
		gwd_decorator.set_active(True)
	decorator_menu.append(gwd_decorator)

# Compiz-Manager Tray Menu		
menu = gtk.Menu()
item = gtk.ImageMenuItem(stock_id=gtk.STOCK_PREFERENCES)
item.connect("activate", configure_menu_activate)
menu.append(item)
item = gtk.ImageMenuItem('Emerald Theme Manager')
if installed('emerald'):
	item.set_sensitive(True)
else:
	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("Start/Reload Window Manager")
item.connect("activate", start_wm)
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_file(pixmap_dir + 'wm-select.png')
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.SeparatorMenuItem()
menu.append(item)
# Window Decorator Options
item = gtk.ImageMenuItem("Start/Reload Window Decorator")
item.connect("activate", start_decorator)
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 Decorator")
gtk.MenuItem.set_submenu(item, decorator_menu)
img_wd = gtk.Image()
img_wd.set_from_file(pixmap_dir + 'wd-select.png')
item.set_image(img_wd)
menu.append(item)
item = gtk.SeparatorMenuItem()
menu.append(item)
# Compiz-Manager About and Quit
item = gtk.ImageMenuItem(stock_id=gtk.STOCK_ABOUT)
item.connect("activate", about_window)
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')
tray = gtk.StatusIcon()
tray.set_from_pixbuf(pixbuf)
tray.set_tooltip("Compiz Fusion Icon")
tray.connect("popup-menu", popup_menu, menu)

# Start Compiz
# activate_compiz_manager()

# Compiz-Manager Main
gtk.main()