#! /usr/bin/python
# -*- coding: UTF-8 -*-

"""
Copyright (C) 2005-07 Adolfo González Blázquez <code@infinicode.org>

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 Street, Fifth Floor, Boston, MA 02110-1301, USA.

If you find any bugs or have any suggestions email: code@infinicode.org
"""

import pygtk
pygtk.require("2.0")
import gtk
import gobject
import pynotify

import os
import sys
import signal
import getopt
import time

from cameramonitor import preferences
from cameramonitor import utils
from cameramonitor import camglobals as glob
from cameramonitor import autostart

class CameraMonitor:

	# Init method
	def __init__(self):
		
		if utils.pid_check(): sys.exit(0)
		else: utils.pid_save()

		self.video_device = ''
		self.timeout = 0
		self.notify = True
		self.autostart = False
		
		self.prefs = preferences.CameraMonitorPreferences('nested')
		self.video_device = self.prefs.preferences_get_video_device()
		self.timeout = self.prefs.preferences_get_timeout()
		self.notify = self.prefs.preferences_get_notify()
		self.autostart = self.prefs.preferences_get_autostart()
		
		if self.autostart: autostart.create_autostart_file()
 		else: autostart.delete_autostart_file()
		
		self.state = False
		
		pynotify.init(glob.name)
		self.create_icon()
		self.menu = self.create_menu()
		
		self.timeout_source = gobject.timeout_add (self.timeout, self.timeout_callback)


	# Checks if camera is on
	def camera_on(self):
		#out = os.popen('lsof /dev/video1', 'r')
		#text = out.read()
		text = os.popen3('fuser '+self.video_device, 'r')[1].read()
		return text != ""

	# Callback: Timeout callback
	def timeout_callback(self):
		
		self.video_device = self.prefs.preferences_get_video_device()
		self.timeout = self.prefs.preferences_get_timeout()
		self.notify = self.prefs.preferences_get_notify()
		
		timeout = self.timeout * 1000
		
		if self.state != self.camera_on():
			if self.camera_on(): 
				self.tray.set_visible(True)
				gtk.gdk.flush()
				if self.notify: self.create_notify("Camera is On\nVideo device: %s" % self.video_device)
				self.state = True
			else:
				if self.notify: self.create_notify("Camera is Off")
				gtk.gdk.flush()
				time.sleep(2)
				self.tray.set_visible(False)
				self.state = False
		
		if timeout != self.timeout:
			self.timeout_source = gobject.timeout_add (self.timeout*1000, self.timeout_callback)
			return False
		else:
			return True
			
	# Callback: exit
	def exit_callback(self, widget):
		gtk.main_quit()
		utils.pid_clean()
		return
		
	# Callback: Icon clicked
	def on_popup_menu(self, status, button, time):
		self.menu.popup(None, None, gtk.status_icon_position_menu, button, time, self.tray)

	# Create tray icon
	def create_icon(self):
		self.tray = gtk.StatusIcon()
		self.tray.set_from_file(glob.image)
		self.tray.set_tooltip('Camera On')
		self.tray.connect('popup-menu', self.on_popup_menu)
		self.tray.set_visible(self.camera_on())
		
	# Displays notification
	def create_notify(self, msg):
		
		n = pynotify.Notification(glob.name_long, msg)
		p = gtk.gdk.pixbuf_new_from_file(glob.image)
		n.set_icon_from_pixbuf(p)
		
		# Attach the notification to status icon if possible
		try:
			n.attach_to_status_icon(self.tray)
		except:
			pass

		n.show()
		
	
	# Creates the Contextual Menu	
	def create_menu(self):
        
		menu = gtk.Menu()
        
		pref = gtk.ImageMenuItem(stock_id=gtk.STOCK_PREFERENCES, accel_group=None)
		pref.connect("activate", self.prefs.preferences_show)
        
		about = gtk.ImageMenuItem(stock_id=gtk.STOCK_ABOUT, accel_group=None)
		about.connect("activate", self.about_show)
        
		sep = gtk.SeparatorMenuItem()
        
		quit = gtk.ImageMenuItem(stock_id=gtk.STOCK_QUIT, accel_group=None)
		quit.connect("activate", self.exit_callback)
        
		menu.add(pref)
		menu.add(about)
		menu.add(sep)
		menu.add(quit)
             
		menu.show_all()
		return menu
		
	# Creates about dialog
	def about_show(self, widget):
		about = gtk.AboutDialog()
		about.set_name(glob.name_long + ' '+ glob.version)
		about.set_authors(glob.authors)
		about.set_comments(glob.description)
		about.set_logo(gtk.gdk.pixbuf_new_from_file(glob.logo))
		about.set_license(glob.license)
		about.set_wrap_license(True)
		about.set_copyright(glob.copyright)

		def openHomePage(widget,url,url2):
			import webbrowser
			webbrowser.open_new(url)

		gtk.about_dialog_set_url_hook(openHomePage,glob.website)
		about.set_website(glob.website)
		about.run()
		about.destroy()

# Handle signals 2, 3  and 15
def signal_handler(sig, frame):
	utils.pid_clean()
	gtk.main_quit()
	
# Prints application usage from command line
def command_usage():
    print "Usage: %s [options]" % os.path.basename(sys.argv[0])
    print "\nApplication options:"
    print "	-h, --help	Displays this dialog"
    print "	-p, --prefs	Display the preferences dialog"
    sys.exit(0)

# Parses options passed by command line and acts
def parse_commandline_options():
    try:
        opts, args = getopt.getopt(sys.argv[1:],"hp", ["help","prefs"])
    except:
        print "Invalid options\n"
        command_usage()
        sys.exit(2)

    for o, a in opts:
		if o in ("-h", "--help"):
			command_usage()
		elif o in ("-p", "--prefs"):
			command_preferences()
			sys.exit(0)

# Display Preferences dialog, instead of running the app
def command_preferences():
	pid = utils.pid_read() 
	if not utils.pid_running(pid): utils.display_dialog_warning("Camera Monitor is not running!")
	prefs = preferences.CameraMonitorPreferences('alone')
	prefs.preferences_show(None)
    
	gtk.main()
	

# Main method
def main():
	
	parse_commandline_options()
	
	# Handle signals 2, 3  and 15
	signal.signal(2, signal_handler)
	signal.signal(3, signal_handler)
	signal.signal(15, signal_handler)
	
	camera = CameraMonitor()
	gtk.main()

if __name__ == "__main__":
    main()