#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# We're using PySide, Nokia's official LGPL bindings.
# You can however easily use PyQt (Riverside Computing's GPL bindings) by commenting these and fixing the appropriate imports.
import sys, os, time, thread
import glib, gobject
import pygst
pygst.require("0.10")
import gst
from ctypes import *
import subprocess
from PySide.QtCore import *
from PySide.QtGui import *
from PySide.QtMaemo5 import QMaemo5ValueButton, QMaemo5InformationBox
import dbus.mainloop.qt
import codecs
 
# In Qt, everything is a class.
# We can subclass stuff to do whatever we want - it seems a bit strange at first,
# but it keeps all related functionality in one place, which helps to keep you organised.
#
# We're subclassing 'QWidget' here. QWidget is the base class for all graphical elements in Qt.
# You can do all sorts of cool things like drawing your widget yourself, but we won't get into that.
#
# See also:
#   http://doc.trolltech.com/4.6/qwidget.html

####################
# Global variables #
####################
CooktimerVersion = "0.0.4-17"
Vibration = False
Sound = False
Wakeup = False
Alarmbanner = False
Backlight = False
Volume = 50
defaultVolume = 50
Orientation = "Auto"
Home = os.path.expanduser("~")
CommentChar = '#'
OptionChar =  ' '
Cooktimer_CfgDir = Home + '/.config/cooktimer/'
Cooktimer_CfgFile = Cooktimer_CfgDir + 'cooktimer.cfg'
Cooktimer_ItemFile = Cooktimer_CfgDir + 'cooktimer.items'
Cooktimer_StartItems = Cooktimer_CfgDir + 'cooktimer.start-items'
hoursPicked0 = "00"
minutesPicked0 = "00"
secondsPicked0 = "00"
hoursPicked1 = "00"
minutesPicked1 = "00"
secondsPicked1 = "00"
hoursPicked2 = "00"
minutesPicked2 = "00"
secondsPicked2 = "00"
hoursPicked3 = "00"
minutesPicked3 = "00"
secondsPicked3 = "00"
dishName1 = ""
dishName1banner = ""
dishPicked1Nbr = ""
dishName2 = ""
dishName2banner = ""
dishPicked2Nbr = ""
dishName3 = ""
dishName3banner = ""
dishPicked3Nbr = ""
rowNbr=1
msgTxtPicked1_1 = ""
msgTimePicked1_1 = ""
msgTxtPicked1_2 = ""
msgTimePicked1_2 = ""
msgTxtPicked1_3 = ""
msgTimePicked1_3 = ""
msgTxtPicked2_1 = ""
msgTimePicked2_1 = ""
msgTxtPicked2_2 = ""
msgTimePicked2_2 = ""
msgTxtPicked2_3 = ""
msgTimePicked2_3 = ""
msgTxtPicked3_1 = ""
msgTimePicked3_1 = ""
msgTxtPicked3_2 = ""
msgTimePicked3_2 = ""
msgTxtPicked3_3 = ""
msgTimePicked3_3 = ""
pause1 = False
pause2 = False
pause3 = False
isStopwatchMode1 = False
isStopwatchMode2 = False
isStopwatchMode3 = False
isContinueMode1 = False
isContinueMode1Active = False
isContinueMode1Restore = False
isContinueMode2 = False
isContinueMode2Active = False
isContinueMode2Restore = False
isContinueMode3 = False
isContinueMode3Active = False
isContinueMode3Restore = False
currSelector = 0
playstate = 2
Playbin2 = gst.element_factory_make("playbin2", "player")
Alarmfile = "/opt/cooktimer/alarm-cooktimer.wav"
hPath = ""

##########################################
# gstreamer stuff to play in silent mode #
# concept by Faheem Pervez               #
##########################################
pulse_lib = CDLL("libpulse-mainloop-glib.so.0")
gobject_lib = CDLL("libgobject-2.0.so.0")

g_object_set = gobject_lib.g_object_set

class PA_PROPLIST(Structure):
  _fields_ = [("_opaque_struct", c_int)]

# pa_proplist_*
pa_proplist_new = pulse_lib.pa_proplist_new
pa_proplist_new.restype = POINTER(PA_PROPLIST)
pa_proplist_new.argtypes = [ ]

pa_proplist_sets = pulse_lib.pa_proplist_sets
pa_proplist_sets.restype = c_int
pa_proplist_sets.argtypes = [
        POINTER(PA_PROPLIST),
        c_char_p,
        c_char_p
]

pa_proplist_free = pulse_lib.pa_proplist_free
pa_proplist_sets.restype = None
pa_proplist_sets.argtypes = [
        POINTER(PA_PROPLIST),
]


def parse_config(self, filename):
	options = {}
	f = codecs.open(filename,"r","utf-8")
	for line in f:
		# First, remove comments:
		if CommentChar in line:
			# split on comment char, keep only the part before
			line, comment = line.split(CommentChar, 1)
		# Second, find lines with an option=value:
		if OptionChar in line:
			# split on option char:
			option, value = line.split(OptionChar, 1)
			# strip spaces:
			option = option.strip()
			value = value.strip()
			# store in dictionary:
			options[option] = value
	f.close()
 	return options

def load_dishes(self):
	global OptionChar
	OptionChar = "|"
	cooktimer_items = parse_config(self,Cooktimer_ItemFile)
	DishList = ""
	# make a new list for sorting case-insensitive
	for item in cooktimer_items:
		DishList = DishList + item + '|' + cooktimer_items[item] + "\n"
	contentsList = DishList.split('\n')
	contentsList = contentsList[:-1]
	contentsList.sort(lambda a, b: cmp(a.upper(), b.upper()))
	# initialize array
	dishes = []
	for dish in contentsList:
		item, value  = dish.split(OptionChar,1)
		dishes.append([item,value])
	return dishes

def Alarm(self):
	global playstate
	if Wakeup:
		# Switch on backlight to be sure message is displayed
		strUnlock = "dbus-send --print-reply --system --dest=com.nokia.mce /com/nokia/mce/request com.nokia.mce.request.req_tklock_mode_change string:unlocked"
		QProcess.startDetached(strUnlock)
	if Vibration:
		os.system('dbus-send --system --print-reply --dest=com.nokia.mce /com/nokia/mce/request com.nokia.mce.request.req_start_manual_vibration int32:250 int32:3000')
	if Sound:
			bus = dbus.SessionBus()
			obj = bus.get_object("com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer",
				"/com/nokia/mafw/renderer/gstrenderer")
			state = dbus.Interface(obj, "com.nokia.mafw.renderer")
			playlist, index, playstate, object_id = state.get_status()
			if playstate == 1:
				# Stopped = 0 Playing = 1 Paused = 2 Transitioning = 3
				os.popen("dbus-send --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer com.nokia.mafw.renderer.pause")
			os.system("dbus-send --type=method_call --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer \
				com.nokia.mafw.extension.set_extension_property string:volume variant:uint32:"+str(Volume))
			# use workaround for silent profile
			mainclass = Gstreamer_play()
			thread.start_new_thread(mainclass.start, ())
			gobject.threads_init()

def printMsg(self,message,duration):
        box = QMaemo5InformationBox()
        box.information(self, message, duration)
        box.show()

def format_seconds_to_hhmmss(seconds):
	hours = seconds // (60*60)
	seconds %= (60*60)
	minutes = seconds // 60
	seconds %= 60
	return "%02i:%02i:%02i" % (hours, minutes, seconds)


class MyMainWindow(QMainWindow):
	def __init__(self, parent=None):# first things first, we need to initialise the Qt parent, otherwise it won't work properly.
		#
		super(MyMainWindow, self).__init__(parent)
		self.setAttribute(Qt.WA_Maemo5StackedWindow)
		global Orientation
		global defaultVolume
		self.setWindowTitle("cooktimer")

		# catch dbus signal for keyboard slider
		dbus.mainloop.qt.DBusQtMainLoop(set_as_default=True)
		bus = dbus.SystemBus()
		bus.add_signal_receiver(self.handle_slide, path='/org/freedesktop/Hal/devices/platform_slide', dbus_interface='org.freedesktop.Hal.Device', signal_name='PropertyModified')

		# store current volume
		bus = dbus.SessionBus()
		obj = bus.get_object("com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer", "/com/nokia/mafw/renderer/gstrenderer")
		mafw = dbus.Interface(obj, "com.nokia.mafw.extension")
		defaultVolume = int(mafw.get_extension_property("volume")[1])
		# Create config dir if needed
		if not os.path.exists(Cooktimer_CfgDir):
			os.mkdir(Cooktimer_CfgDir)
		# Create config files if needed
		if not os.path.isfile(Cooktimer_CfgFile):
			try:
				newConfigFile = open(Cooktimer_CfgFile,"w")
			except:
				QMessageBox.critical(self, "Warning",  "Cannot write " + Cooktimer_CfgFile)
			else:
				newConfigFile.write("keepbacklighton true\n")
				newConfigFile.write("vibration true\n")
				newConfigFile.write("wakeup true\n")
				newConfigFile.write("orientation auto\n")
				newConfigFile.write("sound true\n")
				newConfigFile.write("volumelevel 50\n")
				newConfigFile.write("alarmfile /opt/cooktimer/alarm-cooktimer.wav\n")
				newConfigFile.write("alarmbanner true\n")
				newConfigFile.close()
		else:
			keepbacklightset = False
			vibrationset = False
			wakeupset = False
			soundset = False
			volsoundset = False
			orientationset = False
			alarmfileset = False
			alarmbannerset = False
			ConfigFile = open(Cooktimer_CfgFile,"r")
			lines = ConfigFile.readlines()
			for line in lines:
				if 'keepbacklighton' in line:
					keepbacklightset = True
				if 'vibration' in line:
					vibrationset = True
				if 'wakeup' in line:
					wakeupset = True
				if 'sound' in line:
					soundset = True
				if 'volumelevel' in line:
					volsoundset = True
				if 'orientation' in line:
					orientationset = True
				if 'alarmfile' in line:
					alarmfileset = True
				if 'alarmbanner' in line:
					alarmbannerset = True
			ConfigFile.close()
			if not keepbacklightset or not vibrationset or not wakeupset or not soundset or not volsoundset \
			or not orientationset or not alarmfileset or not alarmbannerset:
				ConfigFile = open(Cooktimer_CfgFile,"a")
				if not keepbacklightset:
					ConfigFile.write("keepbacklighton true\n")
				if not vibrationset:
					ConfigFile.write("vibration true\n")
				if not wakeupset:
					ConfigFile.write("wakeup true\n")
				if not soundset:
					ConfigFile.write("sound true\n")
				if not volsoundset:
					ConfigFile.write("volumelevel 50\n")
				if not orientationset:
					ConfigFile.write("orientation auto\n")
				if not alarmfileset:
					ConfigFile.write("alarmfile /opt/cooktimer/alarm-cooktimer.wav\n")
				if not alarmbannerset:
					ConfigFile.write("alarmbanner true\n")
				ConfigFile.close()

		if not os.path.isfile(Cooktimer_ItemFile):
			try:
				newConfigFile = open(Cooktimer_ItemFile,"w")
			except:
				QMessageBox.critical(self, "Warning",  "Cannot write " + Cooktimer_ItemFile)
			else:
				newConfigFile.close()

		if not os.path.isfile(Cooktimer_StartItems):
			try:
				newItemstartupFile = open(Cooktimer_StartItems,"w")
			except:
				QMessageBox.critical(self, "Warning",  "Cannot write " + Cooktimer_StartItems)
			else:
				newItemstartupFile.close()

		###############
		# read config #
		###############
		global OptionChar
		global Alarmfile
		global Alarmbanner
		global Wakeup
		global Vibration
		global Backlight
		global Volume
		global Sound
		OptionChar = " "
		self.cooktimer_opts = parse_config(self,Cooktimer_CfgFile)
		Alarmfile = self.cooktimer_opts["alarmfile"]
		Volume = self.cooktimer_opts["volumelevel"]
		###############
		# Create menu #
		###############
		orientationGroup = QActionGroup(self)
		orientationGroup.setExclusive(True)
		self.landscapeAction = QAction(self.tr('&Landscape') ,self)
		self.landscapeAction.setCheckable(True)
		self.portraitAction = QAction(self.tr('&Portrait') ,self)
		self.portraitAction.setCheckable(True)
		self.autorotateAction = QAction(self.tr('&Autorotate') ,self)
		self.autorotateAction.setCheckable(True)
		orientationGroup.addAction(self.landscapeAction)
		orientationGroup.addAction(self.autorotateAction)
		orientationGroup.addAction(self.portraitAction)
		
		self.configAction = QAction(self.tr('&Settings'), self)
		if self.cooktimer_opts["keepbacklighton"] == "true":
			Backlight = True
		if self.cooktimer_opts["wakeup"] == "true":
			Wakeup = True
		if self.cooktimer_opts["vibration"] == "true":
			Vibration = True
		if self.cooktimer_opts["sound"] == "true":
			Sound = True
		self.orientationAction = QAction( '', self)
		if self.cooktimer_opts["orientation"] == "portrait":
			self.portraitAction.setChecked(True)
			self.setAttribute(Qt.WA_Maemo5PortraitOrientation, True)
			Orientation = "portrait"
		elif self.cooktimer_opts["orientation"] == "landscape":
			self.landscapeAction.setChecked(True)
			self.setAttribute(Qt.WA_Maemo5LandscapeOrientation, True)
			Orientation = "landscape"
		else:
			self.autorotateAction.setChecked(True)
			self.setAttribute(Qt.WA_Maemo5AutoOrientation, True)
			Orientation = "auto"
		if self.cooktimer_opts["alarmbanner"] == "true":
			Alarmbanner = True
		editAction = QAction(self.tr('&Edit dishes'), self)
		self.alarmfileAction = QAction(self.tr('&Custom alarm sound'), self)
		helpAction = QAction( self.tr('&Help'), self)
		aboutAction = QAction( self.tr('&About'), self)

		########################
		# create menu from bar #
		########################
		menubar = self.menuBar()
		mainMenu = menubar.addMenu('&MainMenu')
		mainMenu.addActions(orientationGroup.actions())
		mainMenu.addAction(self.configAction)
		mainMenu.addAction(self.alarmfileAction)
		mainMenu.addAction(editAction)
		mainMenu.addAction(helpAction)
		mainMenu.addAction(aboutAction)

		##################
		# Define actions #
		##################
		self.alarmfileAction.triggered.connect(self.alarmfilePushed)
		self.portraitAction.triggered.connect(self.portraitPushed)
		self.landscapeAction.triggered.connect(self.landscapePushed)
		self.autorotateAction.triggered.connect(self.autorotatePushed)
		editAction.triggered.connect(self.editPushed)
		helpAction.triggered.connect(self.helpPushed)
		aboutAction.triggered.connect(self.aboutPushed)
		self.configAction.triggered.connect(self.slotConfig)
		self.connect(self, SIGNAL("didSomething"), self.checkIsDim)

		#############################
		# Prevent backlight dimming #
		#############################
		self.dimtimer = QTimer()
		self.dimtimer.timeout.connect(self.KeepBackLightOn)
		# get timeout value
		self.screendim_timeout = (int(os.popen('gconftool-2 --get /system/osso/dsm/display/display_dim_timeout').read())-1)*1000
		if Backlight:
			self.dimtimer.start(self.screendim_timeout)
		################################################################
		# set initial orientation to landscape if kb open and portrait #
		################################################################
		kb_state = os.popen('cat /sys/devices/platform/gpio-switch/slide/state').read().strip()
		if kb_state == "open" and self.cooktimer_opts["orientation"] == "portrait":
			self.setAttribute(Qt.WA_Maemo5LandscapeOrientation, True)

		self.form_widget = FormWidget(self)
		self.setCentralWidget(self.form_widget)

	def helpPushed(self):
		a = HelpWindow(self)
		a.show()

	def slotConfig(self):
		# show config screen
		a = ConfigWindow(self)
		self.connect(a, SIGNAL("destroyed()"),self.checkIsDim)
		a.show()

	def checkIsDim(self):
		if Backlight and not self.dimtimer.isActive():
			self.dimtimer.start(self.screendim_timeout)
		if not Backlight and self.dimtimer.isActive():
			self.dimtimer.stop()

	def handle_slide(self,var1,var2):
		kb_state = os.popen('cat /sys/devices/platform/gpio-switch/slide/state').read().strip()
		if kb_state == "open" and Orientation == "portrait":
			self.setAttribute(Qt.WA_Maemo5LandscapeOrientation, True)
		elif Orientation == "portrait":
			self.setAttribute(Qt.WA_Maemo5PortraitOrientation, True)
		
	def KeepBackLightOn(self):
		strUnlock = "dbus-send --system --type=method_call --dest=com.nokia.mce /com/nokia/mce/request com.nokia.mce.request.req_display_blanking_pause"
		QProcess.startDetached(strUnlock)

	def saveSettings(self):
		global OptionChar
		OptionChar = " "
		self.cooktimer_opts = parse_config(self,Cooktimer_CfgFile)
		if Vibration:
			self.cooktimer_opts["vibration"] = "true"
		else: self.cooktimer_opts["vibration"] = "false"
		if Backlight:
			self.cooktimer_opts["keepbacklighton"] = "true"
		else: self.cooktimer_opts["keepbacklighton"] = "false"
		if Wakeup:
			self.cooktimer_opts["wakeup"] = "true"
		else: self.cooktimer_opts["wakeup"] = "false"
		if Sound:
			self.cooktimer_opts["sound"] = "true"
		else: self.cooktimer_opts["sound"] = "false"
		if self.portraitAction.isChecked():
			self.cooktimer_opts["orientation"] = "portrait"
			Orientation = "portrait"
		if self.landscapeAction.isChecked():
			self.cooktimer_opts["orientation"] = "landscape"
			Orientation = "landscape"
		if self.autorotateAction.isChecked():
			self.cooktimer_opts["orientation"] = "auto"
			Orientation = "auto"
		if Alarmbanner:
			self.cooktimer_opts["alarmbanner"] = "true"
		else: self.cooktimer_opts["alarmbanner"] = "false"
		self.cooktimer_opts["volumelevel"] = str(Volume)
		self.cooktimer_opts["alarmfile"] = Alarmfile
		try:
			newConfigFile = open(Cooktimer_CfgFile,"w")
			for option in self.cooktimer_opts:
				newConfigFile.write(option + " " + self.cooktimer_opts[option] + "\n")
			newConfigFile.close()
			successMsg = self.tr("Configuration is successfully saved")
			os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
				/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
				string:"'+successMsg+'"')
		except:
			failMsg = self.tr("Could NOT save Configuration!")
			os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
				/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
				string:"'+failMsg+'"')

	def alarmfilePushed(self):
		widget = fileWindow(self)
		widget.show()

	def portraitPushed(self):
		if self.cooktimer_opts["orientation"] != "portrait":
			self.setAttribute(Qt.WA_Maemo5PortraitOrientation, True)
			Orientation = "portrait"
			self.saveSettings()
	
	def landscapePushed(self):
		if self.cooktimer_opts["orientation"] != "landscape":
			self.setAttribute(Qt.WA_Maemo5LandscapeOrientation, True)
			Orientation = "landscape"
			self.saveSettings()

	def autorotatePushed(self):
		if self.cooktimer_opts["orientation"] != "auto":
			self.setAttribute(Qt.WA_Maemo5AutoOrientation, True)
			Orientation = "auto"
			self.saveSettings()

	def editPushed(self):
		widget = itemWindow(self)
		widget.show()

	def aboutPushed(self):
		d = QDialog(self)
		vbox = QVBoxLayout()
		verticalLayout = QVBoxLayout() 
		d.setWindowTitle(self.tr("About")+" cooktimer")
		verticalLayout.addWidget(QLabel("<center><img src=/opt/usr/share/icons/hicolor/64x64/apps/cooktimer.png /></center>"),0)
		verticalLayout.addWidget(QLabel("<center><b><big>Cooktimer "+CooktimerVersion+"<big></b></center>"),1)
		verticalLayout.addWidget(QLabel("<center>"+self.tr("Created by")+" Arno Dekker (ade)</center>"),2)
		verticalLayout.addWidget(QLabel("<center><small>"+self.tr("Assistance by")+" Marc P"+"\xc3\xb6".decode('utf-8')+"pperl (rasmarc)</small></center><br>"),3)
		vbox.addLayout (verticalLayout)
		d.setLayout(vbox)
		d.show()

class HelpWindow(QMainWindow):
	def __init__(self, parent):
		QMainWindow.__init__(self, parent)
		self.setWindowTitle(self.tr("Help"))
		self.setAttribute(Qt.WA_Maemo5StackedWindow)
		self.setAttribute(Qt.WA_DeleteOnClose)
		area = QScrollArea()
		lay = QHBoxLayout()
		lay.addWidget(area)
		self.wg = QWidget()
		area.setWidget(self.wg)
		self.setCentralWidget(area)
		self.wg.resize(478, 740)
		sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Expanding)
		sizePolicy.setHorizontalStretch(0)
		sizePolicy.setVerticalStretch(0)
		sizePolicy.setHeightForWidth(self.wg.sizePolicy().hasHeightForWidth())
		self.wg.setSizePolicy(sizePolicy)
		grid = QGridLayout(self.wg)
		infoTXT = "<font style='color: black'>" \
			"<center><h3>"+self.tr("Cooktimer")+"</b></center></h3>" \
			+self.tr("Cooktimer provides three timers for preparing the perfect meal.") + "<p>" \
			+self.tr("Apart from the obvious functions and settings, there are some not so easily spotted:") \
			+ "<UL>" \
			"<LI>" + self.tr("Pressing a running timer bar will pause the alarm") + \
			"<LI>" + self.tr("Pressing a paused timer bar will unpause the alarm") + \
			"<LI>" + self.tr("Pressing a timer bar after showing \"00:00:00\" will silence it's alarm") + \
			"<LI>" + self.tr("Long-pressing a dishpicker will reset all dish settings") + \
			"<LI>" + self.tr("Long-pressing a timepicker will toggle continue mode") + \
			"<LI>" + self.tr("Long-pressing a timer bar will toggle stopwatch mode") + \
			"<LI>" + self.tr("By pushing the add icon in the \"edit dishes\" menu you can set interim messages and make it preload at startup") + \
			"</UL>"
		termsInfo = QTextBrowser()
		termsInfo.setMinimumSize(QSize(330, 340))
		termsInfo.setHtml( infoTXT )
		font = QFont()
		font.setPointSize(16)
		termsInfo.setFont(font)
		grid.addWidget(termsInfo, 0, 0)
		self.wg.show()
		self.connect(QApplication.desktop(), SIGNAL("resized(int)"), self.orientationChanged)
		# set correct orientation at start
		self.orientationChanged()

	def orientationChanged(self):
		screenGeometry = QApplication.desktop().screenGeometry()
		if screenGeometry.width() < screenGeometry.height():
			# portrait
			self.wg.resize(478, 740)
		else:
			self.wg.resize(792, 420)

class ConfigWindow(QMainWindow):
	def __init__(self,parent):
		QMainWindow.__init__(self,parent)
		self.setWindowTitle(self.tr("Configuration cooktimer"))
		self.setAttribute(Qt.WA_Maemo5StackedWindow)
		self.setAttribute(Qt.WA_DeleteOnClose)
		area = QScrollArea()
		lay = QVBoxLayout()
		lay.addWidget(area)
		self.wg = QWidget()
		area.setWidget(self.wg)
		self.setCentralWidget(area)
		self.grid = QGridLayout(self.wg)
		self.wg.show()
		area.show()
		self.setLayout(self.grid)
		# define checkboxes
		self.backlightCheckbox = QCheckBox(self.tr("Keep backlight on"),self)
		self.backlightCheckbox.setMinimumWidth(370)
		self.screenwakeupCheckbox = QCheckBox(self.tr("Wakeup screen on alarm"),self)
		self.vibrateCheckbox = QCheckBox(self.tr("Vibrate on alarm"),self)
		self.soundCheckbox = QCheckBox(self.tr("Sound on alarm"),self)
		self.bannerCheckbox = QCheckBox(self.tr("Alarm banner"),self)
		self.volSlider = QSlider(Qt.Horizontal, self)
		self.volSlider.setMinimum(0);
		self.volSlider.setMaximum(100);
		self.volSlider.setValue(int(Volume))
		self.volLabel = QPushButton()
		self.volLabel.setStyleSheet("background: transparent; border: none")
		self.volLabel.setMaximumHeight(60)
		# set volume info
		self.volChange(int(Volume))
		# set checked/unchecked
		if Backlight:
			self.backlightCheckbox.setChecked(True)
		if Wakeup:
			self.screenwakeupCheckbox.setChecked(True)
		if Vibration:
			self.vibrateCheckbox.setChecked(True)
		if Sound:
			self.soundCheckbox.setChecked(True)
		if Alarmbanner:
			self.bannerCheckbox.setChecked(True)
		self.saveConfigButton = QPushButton(self.tr("Done"),self)
		self.saveConfigButton.setMinimumHeight(80)
		self.saveConfigButton.setStyleSheet("QPushButton { font:bold; }")
		# set correct layout
		self.orientationChanged()
		# signals
		self.connect(self.saveConfigButton, SIGNAL("clicked()"),self.saveConfig)
		self.connect(QApplication.desktop(), SIGNAL("resized(int)"), self.orientationChanged)
		self.volSlider.valueChanged[int].connect(self.volChange)

	def volChange(self,value):
		if value > 0 and value < 100:
			self.volLabel.setText(self.tr("Alarm volume: ") + str(value))
		if value == 0:
			self.volLabel.setIcon(QIcon.fromTheme("statusarea_volume_mute"))
			self.volLabel.setText(self.tr("Alarm muted"))
		elif value > 0 and value <= 30:
			self.volLabel.setIcon(QIcon.fromTheme("statusarea_volumelevel1"))
		elif value > 30 and value <= 60:
			self.volLabel.setIcon(QIcon.fromTheme("statusarea_volumelevel2"))
		elif value > 60 and value <= 90:
			self.volLabel.setIcon(QIcon.fromTheme("statusarea_volumelevel3"))
		elif value > 90 and value <= 99:
			self.volLabel.setIcon(QIcon.fromTheme("statusarea_volumelevel4"))
		else:
			self.volLabel.setIcon(QIcon.fromTheme("statusarea_volumelevel4"))
			self.volLabel.setText(self.tr("Alarm volume: max"))
		
	def saveSettings(self):
		global OptionChar
		OptionChar = " "
		self.cooktimer_opts = parse_config(self,Cooktimer_CfgFile)
		if Vibration:
			self.cooktimer_opts["vibration"] = "true"
		else: self.cooktimer_opts["vibration"] = "false"
		if Backlight:
			self.cooktimer_opts["keepbacklighton"] = "true"
		else: self.cooktimer_opts["keepbacklighton"] = "false"
		if Wakeup:
			self.cooktimer_opts["wakeup"] = "true"
		else: self.cooktimer_opts["wakeup"] = "false"
		if Sound:
			self.cooktimer_opts["sound"] = "true"
		else: self.cooktimer_opts["sound"] = "false"
		self.cooktimer_opts["orientation"] = Orientation
		if Alarmbanner:
			self.cooktimer_opts["alarmbanner"] = "true"
		else: self.cooktimer_opts["alarmbanner"] = "false"
		self.cooktimer_opts["volumelevel"] = str(Volume)
		self.cooktimer_opts["alarmfile"] = Alarmfile
		try:
			newConfigFile = open(Cooktimer_CfgFile,"w")
			for option in self.cooktimer_opts:
				newConfigFile.write(option + " " + self.cooktimer_opts[option] + "\n")
			newConfigFile.close()
			successMsg = self.tr("Configuration is successfully saved")
			os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
				/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
				string:"'+successMsg+'"')
		except:
			failMsg = self.tr("Could NOT save Configuration!")
			os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
				/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
				string:"'+failMsg+'"')
		self.emit(SIGNAL("didSomething"))
		self.close()

	def saveConfig(self):
		global Wakeup
		global Vibration
		global Sound
		global Alarmbanner
		global Backlight
		global Volume
		if self.screenwakeupCheckbox.isChecked():
			Wakeup = True
		else: Wakeup = False
		if self.bannerCheckbox.isChecked():
			Alarmbanner = True
		else: Alarmbanner = False
		if self.soundCheckbox.isChecked():
			Sound = True
		else: Sound = False
		if self.vibrateCheckbox.isChecked():
			Vibration = True
		else: Vibration = False
		if self.backlightCheckbox.isChecked():
			Backlight = True
		else: Backlight = False
		Volume = self.volSlider.value()
		self.saveSettings()

	def orientationChanged(self):
		screenGeometry = QApplication.desktop().screenGeometry()
		if screenGeometry.width() > screenGeometry.height():
			# landscape
			self.wg.resize(780,300)
			self.wg.setMinimumHeight(420)
			self.wg.setMaximumHeight(420)
			# first remove layout
			self.grid.removeWidget(self.backlightCheckbox)
			self.grid.removeWidget(self.screenwakeupCheckbox)
			self.grid.removeWidget(self.vibrateCheckbox)
			self.grid.removeWidget(self.soundCheckbox)
			self.grid.removeWidget(self.bannerCheckbox)
			self.grid.removeWidget(self.volLabel)
			self.grid.removeWidget(self.volSlider)
			self.grid.removeWidget(self.saveConfigButton)
			# then add again
			self.grid.addWidget(self.backlightCheckbox,1,0)
			self.grid.addWidget(self.screenwakeupCheckbox,1,1)
			self.grid.addWidget(self.vibrateCheckbox,2,0)
			self.grid.addWidget(self.soundCheckbox,2,1)
			self.grid.addWidget(self.bannerCheckbox,3,0)
			self.grid.addWidget(self.volLabel,3,1)
			self.grid.addWidget(self.volSlider,4,0,1,2)
			self.grid.addWidget(self.saveConfigButton,5,0,1,2)
		else:
			# portrait
			self.wg.resize(470,680)
			self.wg.setMinimumHeight(740)
			self.wg.setMaximumHeight(740)
			# first remove layout
			self.grid.removeWidget(self.backlightCheckbox)
			self.grid.removeWidget(self.screenwakeupCheckbox)
			self.grid.removeWidget(self.vibrateCheckbox)
			self.grid.removeWidget(self.soundCheckbox)
			self.grid.removeWidget(self.bannerCheckbox)
			self.grid.removeWidget(self.volSlider)
			self.grid.removeWidget(self.volLabel)
			self.grid.removeWidget(self.saveConfigButton)
			# then add again
			self.grid.addWidget(self.backlightCheckbox,1,0)
			self.grid.addWidget(self.screenwakeupCheckbox,2,0)
			self.grid.addWidget(self.vibrateCheckbox,3,0)
			self.grid.addWidget(self.soundCheckbox,4,0)
			self.grid.addWidget(self.bannerCheckbox,5,0)
			self.grid.addWidget(self.volLabel,6,0)
			self.grid.addWidget(self.volSlider,7,0)
			self.grid.addWidget(self.saveConfigButton,8,0)


class itemWindow(QMainWindow):
	def __init__(self,parent):
		QMainWindow.__init__(self,parent)
		self.setWindowTitle(self.tr("Dish cooktimes"))
		self.setAttribute(Qt.WA_Maemo5StackedWindow)
		self.setAttribute(Qt.WA_DeleteOnClose)
		self.wg = QWidget(self)

		# create a scroll area for the modules to load
		global OptionChar
		self.grid2 = QGridLayout()
		grid = QGridLayout()
		scrollingWidget = QWidget()
		scrollingWidget.setLayout(self.grid2)
		 
		self.myScrollArea = QScrollArea()
		self.myScrollArea.setWidgetResizable(True)
		self.myScrollArea.setEnabled(True)
		 
		self.myScrollArea.setWidget(scrollingWidget)
		self.hbox = QGridLayout()
		self.hbox.addWidget(self.myScrollArea,0,0,1,2)
		 
		self.wg.setMinimumHeight(1050)
		self.wg.setMaximumHeight(1050)
		# Layout
		grid = QGridLayout()
		self.wg.setLayout(self.hbox)
		self.grid2.setColumnMinimumWidth(0,150)
		grid.setHorizontalSpacing(0)
		grid.setVerticalSpacing(0)
		self.saveItemButton = QPushButton(self.tr("Done"),self)
		self.addItemButton = QPushButton(self.tr("New"),self)
		OptionChar =  '|'
		cooktimer_items = parse_config(self,Cooktimer_ItemFile)
		self.maxLen=25
		self.teller=1
		self.var_num=1
		DishList = ""
		# make a new list for sorting case-insensitive
		for item in cooktimer_items:
			DishList = DishList + item + '|' + cooktimer_items[item] + "\n"
		contentsList = DishList.split('\n')
		contentsList = contentsList[:-1]
		contentsList.sort(lambda a, b: cmp(a.upper(), b.upper()))
		self.signalMapper = QSignalMapper(self) 
		for dish in contentsList:
			item, value  = dish.split('|',1)
			hh_mi_ss = cooktimer_items[item][:8].split(':',2)
			hh = hh_mi_ss[0]
			mi = hh_mi_ss[1]
			ss = hh_mi_ss[2]
			globals()['ItemName%s' % self.var_num] = QLineEdit(item)
			globals()['ItemName%s' % self.var_num].setMaxLength(self.maxLen)
			self.grid2.addWidget(globals()['ItemName%s' % self.var_num],self.teller,0)
			globals()['timeSel%s' % self.var_num] = QMaemo5ValueButton(self.tr("time"))
			globals()['timeSel%s' % self.var_num].setValueLayout(QMaemo5ValueButton.ValueUnderTextCentered)
			globals()['timeSel%s' % self.var_num].setValueText(hh+":"+mi+":"+ss)
			globals()['timeSel%s' % self.var_num].setStatusTip(cooktimer_items[item])
			self.grid2.addWidget(globals()['timeSel%s' % self.var_num], self.teller, 1)
			self.signalMapper.setMapping(globals()['timeSel%s' % self.var_num],str(self.var_num))
			self.connect(globals()['timeSel%s' % self.var_num], SIGNAL("clicked()"), self.signalMapper, SLOT("map()"))

			globals()['addButton%s' % self.var_num] = QPushButton()
			globals()['addButton%s' % self.var_num].setIcon(QIcon.fromTheme("general_add"))
			globals()['addButton%s' % self.var_num].setStyleSheet("background: transparent; border: none")
			self.grid2.addWidget(globals()['addButton%s' % self.var_num], self.teller, 2)
			self.signalMapper.setMapping(globals()['addButton%s' % self.var_num],-self.var_num)
			self.connect(globals()['addButton%s' % self.var_num], SIGNAL("clicked()"), self.signalMapper, SLOT("map()"))

			globals()['clearButton%s' % self.var_num] = QPushButton()
			globals()['clearButton%s' % self.var_num].setIcon(QIcon.fromTheme("general_delete"))
			globals()['clearButton%s' % self.var_num].setStyleSheet("background: transparent; border: none")
			self.grid2.addWidget(globals()['clearButton%s' % self.var_num], self.teller, 3)
			self.signalMapper.setMapping(globals()['clearButton%s' % self.var_num],self.var_num)
			self.connect(globals()['clearButton%s' % self.var_num], SIGNAL("clicked()"), self.signalMapper, SLOT("map()"))

			self.teller +=1
			self.var_num +=1

		self.connect(self.signalMapper, SIGNAL("mapped(int)"), self.Clear)
		self.connect(self.signalMapper, SIGNAL("mapped(const QString &)"), self.TimeSel)
		self.connect(QApplication.desktop(), SIGNAL("resized(int)"), self.orientationChanged)
		self.connect(self.addItemButton, SIGNAL("clicked()"),self.Additems)
		self.connect(self.saveItemButton, SIGNAL("clicked()"),self.Saveitems)

		self.wg.show()
		self.orientationChanged()

	def Clear(self,waarde):
		# waarde equals rownbr
		if waarde < 0:
			global rowNbr
			rowNbr = abs(waarde)
			widget = extItemWindow(self)
			widget.show()
		else:
			globals()['ItemName%s' % waarde].clear()
			globals()['timeSel%s' % waarde].setValueText("00:00:00")
			globals()['ItemName%s' % waarde].hide()
			globals()['timeSel%s' % waarde].hide()
			globals()['addButton%s' % waarde].hide()
			globals()['clearButton%s' % waarde].hide()

	def TimeSel(self,waarde):
		global secondsPicked0
		global minutesPicked0
		global hoursPicked0
		global currSelector

		currSelector = 0
		hh_mi_ss = globals()['timeSel%s' % waarde].valueText().split(':',2)
		hoursPicked0 = hh_mi_ss[0]
		minutesPicked0 = hh_mi_ss[1]
		secondsPicked0 = hh_mi_ss[2]

		timePick = TimePickDialog(self)
		timePick.show()  
		hours = '%02d' % int(hoursPicked0)
		minutes = '%02d' % int(minutesPicked0)
		seconds = '%02d' % int(secondsPicked0)
		timestring = hours + ":" + minutes + ":" + seconds
		globals()['timeSel%s' % waarde].setValueText(timestring)

	def orientationChanged(self):
		screenGeometry = QApplication.desktop().screenGeometry()
		if screenGeometry.width() > screenGeometry.height():
			# landscape
			self.wg.resize(800,362)
			self.wg.setMinimumHeight(430)
			self.wg.setMaximumHeight(430)
			self.myScrollArea.resize(800,362)
			self.myScrollArea.setMinimumHeight(415)
			self.myScrollArea.setMaximumHeight(415)
			self.hbox.removeWidget(self.addItemButton)
			self.hbox.removeWidget(self.saveItemButton)
			self.hbox.addWidget(self.addItemButton,0,2,Qt.AlignBottom)
			self.hbox.addWidget(self.saveItemButton,1,2,Qt.AlignBottom)
			self.addItemButton.setMaximumWidth(160)
			self.saveItemButton.setMaximumWidth(160)
		else:
			# portrait
			self.wg.resize(480,675)
			self.wg.setMinimumHeight(755)
			self.wg.setMaximumHeight(755)
			self.myScrollArea.resize(480,675)
			self.myScrollArea.setMaximumHeight(675)
			self.myScrollArea.setMinimumHeight(675)
			self.hbox.removeWidget(self.addItemButton)
			self.hbox.removeWidget(self.saveItemButton)
			self.hbox.addWidget(self.addItemButton,17,0)
			self.hbox.addWidget(self.saveItemButton,17,1)
			self.addItemButton.setMaximumWidth(16777215)
			self.saveItemButton.setMaximumWidth(16777215)

	def Saveitems(self):
		try:
			newItemFile = codecs.open(Cooktimer_ItemFile,"w", encoding="utf-8")
		except:
			QMessageBox.critical(self, "Warning",  "Cannot write " + Cooktimer_ItemFile)	
		else:
			for count in range(1,self.teller):
				allInfo = globals()['timeSel%s' % count].statusTip().split('|')
				itemtxt = globals()['timeSel%s' % count].valueText()
				if len(allInfo) > 1:
					msgTxt1 = allInfo[1]
					msgTime1 = allInfo[2].strip()
					itemtxt = itemtxt + '|' + msgTxt1 + '|' + msgTime1
				if len(allInfo) > 3:
					msgTxt2 = allInfo[3]
					msgTime2 = allInfo[4].strip()
					itemtxt = itemtxt + '|' + msgTxt2 + '|' + msgTime2
				if len(allInfo) > 5:
					msgTxt3 = allInfo[5]
					msgTime3 = allInfo[6].strip()
					itemtxt = itemtxt + '|' + msgTxt3 + '|' + msgTime3
				if globals()['ItemName%s' % count ].text() != "":
					newItemFile.write(globals()['ItemName%s' % count ].text() + "|" + \
					itemtxt + "\n")
			newItemFile.close()
			successMsg = self.tr("Configuration is successfully saved")
			os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
				/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
				string:"'+successMsg+'"')
		self.close()

	def Additems(self):
		globals()['ItemName%s' % self.var_num] = QLineEdit()
		globals()['ItemName%s' % self.var_num].setMaxLength(self.maxLen)
		self.grid2.addWidget(globals()['ItemName%s' % self.var_num],self.teller,0)
		globals()['timeSel%s' % self.var_num] = QMaemo5ValueButton(self.tr("time"))
		globals()['timeSel%s' % self.var_num].setValueLayout(QMaemo5ValueButton.ValueUnderTextCentered)
		globals()['timeSel%s' % self.var_num].setValueText("00:00:00")
		self.grid2.addWidget(globals()['timeSel%s' % self.var_num], self.teller, 1)
		self.signalMapper.setMapping(globals()['timeSel%s' % self.var_num],str(self.var_num))
		self.connect(globals()['timeSel%s' % self.var_num], SIGNAL("clicked()"), self.signalMapper, SLOT("map()"))
		globals()['addButton%s' % self.var_num] = QPushButton()
		globals()['addButton%s' % self.var_num].setIcon(QIcon.fromTheme("general_add"))
		globals()['addButton%s' % self.var_num].setStyleSheet("background: transparent; border: none")
		self.grid2.addWidget(globals()['addButton%s' % self.var_num], self.teller, 2)
		globals()['addButton%s' % self.var_num].setEnabled(False)
		self.signalMapper.setMapping(globals()['addButton%s' % self.var_num],-self.var_num)
		self.connect(globals()['addButton%s' % self.var_num], SIGNAL("clicked()"), self.signalMapper, SLOT("map()"))
		globals()['clearButton%s' % self.var_num] = QPushButton()
		globals()['clearButton%s' % self.var_num].setIcon(QIcon.fromTheme("general_delete"))
		globals()['clearButton%s' % self.var_num].setStyleSheet("background: transparent; border: none")
		self.grid2.addWidget(globals()['clearButton%s' % self.var_num], self.teller, 3)
		self.signalMapper.setMapping(globals()['clearButton%s' % self.var_num],self.var_num)
		self.connect(globals()['clearButton%s' % self.var_num], SIGNAL("clicked()"), self.signalMapper, SLOT("map()"))
		globals()['timeSel%s' % self.var_num].show()
		globals()['ItemName%s' % self.var_num].setFocus(Qt.OtherFocusReason)
		self.myScrollArea.ensureWidgetVisible(globals()['timeSel%s' % self.var_num])
		self.teller +=1
		self.var_num +=1

class fileWindow(QWidget):
	def __init__(self,parent):
		super(fileWindow, self).__init__(parent)
		self.wg = QDialog(self)
		self.wg.resize(398, 692)
		sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
		sizePolicy.setHorizontalStretch(0)
		sizePolicy.setVerticalStretch(0)
		sizePolicy.setHeightForWidth(self.wg.sizePolicy().hasHeightForWidth())
		self.wg.setSizePolicy(sizePolicy)

		self.wg.setWindowTitle(self.tr("Choose soundfile"))
		# folderbutton up
		self.folderButton_up = QPushButton(self.wg)
		self.folderButton_up.setIcon(QIcon.fromTheme("filemanager_folder_up"))
		self.folderButton_up.setMinimumSize(QSize(74,70))
		self.folderButton_up.setMaximumSize(QSize(74,70))
		# folder display
		self.folderButton = QMaemo5ValueButton(self.wg)
		self.folderButton.setIcon(QIcon.fromTheme("general_folder"))
		self.folderButton.setMinimumSize(QSize(0,70))
		# file list
		self.listWidget = QListWidget(self.wg)
		sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
		sizePolicy.setHeightForWidth(self.listWidget.sizePolicy().hasHeightForWidth())
		self.listWidget.setSizePolicy(sizePolicy)
		self.listWidget.setMinimumSize(QSize(200, 0))
		self.listWidget.setContextMenuPolicy(Qt.CustomContextMenu)
		self.listWidget.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
		self.listWidget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
		# add to grid
		self.grid = QGridLayout(self.wg)
		self.grid.addWidget(self.folderButton_up,0,0,1,1)
		self.grid.addWidget(self.folderButton,0,1,1,1)
		self.grid.addWidget(self.listWidget, 2, 0, 1, 2)
		# actions
		self.connect(QApplication.desktop(), SIGNAL("resized(int)"), self.orientationChanged)
		self.connect(self.folderButton_up, SIGNAL("clicked()"),self.on_folderButton_up_clicked)
		self.connect(self.folderButton, SIGNAL("clicked()"),self.on_folderButton_clicked)
		self.connect(self.listWidget, SIGNAL("itemClicked(QListWidgetItem *)"), self.on_listWidget_itemClicked)

		# set initial path
		path = os.path.dirname(Alarmfile)
		if not os.path.isdir(path):
			path = "/home/user/MyDocs/"
		fileInfo = QFileInfo(path)
		self.folderButton.setText( fileInfo.fileName() )
		if path == "/":
			self.folderButton.setText( "/" )
			self.folderButton.setValueText( "" )
		self.FillBrowser(path)
		self.wg.show()

	def orientationChanged(self):
		screenGeometry = QApplication.desktop().screenGeometry()
		if screenGeometry.width() < screenGeometry.height():
			# portrait
			self.wg.resize(398, 692)

	def FillBrowser (self,Directory):
		global hPath
		hPath = Directory
		if hPath == "/":
			self.folderButton_up.setDisabled(True)
		else:
			self.folderButton_up.setDisabled(False)
		self.folderButton.setText( QFileInfo(Directory).fileName() )
		self.folderButton.setValueText(Directory)
		if Directory == "/":
			self.folderButton.setText("/")
			self.folderButton.setValueText("")
		self.listWidget.clear()

		# sort dirs/files case-insensitive
		dirs = sorted([d for d in os.listdir(Directory) if os.path.isdir(Directory + os.path.sep + d)])
		dirs.sort(key=lambda y: y.lower())
		filelist = sorted([f for f in os.listdir(Directory) if os.path.isfile(Directory + os.path.sep + f)])
		filelist.sort(key=lambda y: y.lower())
		dirs.extend(filelist)

		# add revelant ones to the list
		teller = 0
		audio_ext = ('.mp3','.wav','.ogg')
		for fileName in dirs:
			teller += 1
			f=os.path.join(Directory, fileName)
			if fileName == "." or fileName == "..":
				continue
			elif os.path.isdir(f):
				item1 = QListWidgetItem( self.listWidget )
				item1.setText(fileName)
				if fileName == ".videos":
					item1.setIcon(QIcon.fromTheme("filemanager_video_folder"))
				elif fileName == ".sounds":
					item1.setIcon(QIcon.fromTheme("filemanager_audio_folder"))
				elif fileName == "DCIM":
					item1.setIcon(QIcon.fromTheme("filemanager_camera_folder"))
				elif fileName == ".documents":
					item1.setIcon(QIcon.fromTheme("filemanager_document_folder"))
				elif fileName == ".images":
					item1.setIcon(QIcon.fromTheme("filemanager_image_folder"))
				else:
					item1.setIcon(QIcon.fromTheme("general_folder"))

				self.listWidget.insertItem( teller, item1 )
			elif os.path.isfile(f):
				if fileName.lower().endswith((audio_ext)):
					item1 = QListWidgetItem( self.listWidget )
					item1.setText(fileName)
					item1.setIcon(QIcon.fromTheme("general_audio_file"))
					self.listWidget.insertItem( teller, item1 )

		if self.listWidget.count() > 0:
			self.listWidget.scrollToItem(self.listWidget.item(0))

	def on_folderButton_up_clicked(self):
		if  hPath == "/":
			return
		nPath = os.path.dirname(os.path.dirname(hPath+'/'))
		if nPath == "":
			nPath = "/"
			self.folderButton_up.setDisabled(True)
		else:
			self.folderButton_up.setDisabled(False)
		self.FillBrowser( nPath )
		
	def on_listWidget_itemClicked(self,item):
		global Alarmfile
		temp = hPath
		if temp != "/":
			temp = temp + "/"
		temp =temp + item.text()

		if os.path.isfile(temp):
			# save the newly chosen alarmfile preference
			Alarmfile = temp
			OptionChar = " "
			self.cooktimer_opts = parse_config(self,Cooktimer_CfgFile)
			self.cooktimer_opts["alarmfile"] = Alarmfile
			try:
				newConfigFile = open(Cooktimer_CfgFile,"w")
				for option in self.cooktimer_opts:
					newConfigFile.write(option + " " + self.cooktimer_opts[option] + "\n")
				newConfigFile.close()
				successMsg = self.tr("Configuration is successfully saved")
				os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
					/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
					string:"'+successMsg+'"')
			except:
				failMsg = self.tr("Could NOT save Configuration!")
				os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
					/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
					string:"'+failMsg+'"')
			self.wg.close()
		elif os.path.isdir(temp):
				self.FillBrowser(temp)

	def on_folderButton_clicked(self):
		widget = folderWindow(self)
		widget.show()
		
	def on_folderButton1_clicked(self):
		self.FillBrowser( "/home/user/MyDocs" )

	def on_folderButton2_clicked(self):
		self.FillBrowser( "/opt/cooktimer" )

	def on_folderButton3_clicked(self):
		self.FillBrowser( "/" )

class folderWindow(QWidget):
	def __init__(self,parent):
		super(folderWindow, self).__init__(parent)
		self.wg = QDialog(self)
		#self.wg.resize(392, 692)
		sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
		sizePolicy.setHorizontalStretch(0)
		sizePolicy.setVerticalStretch(0)
		sizePolicy.setHeightForWidth(self.wg.sizePolicy().hasHeightForWidth())
		self.wg.setSizePolicy(sizePolicy)
		self.wg.setWindowTitle(self.tr("Select folder"))
		# folders display
		self.folderButton1 = QMaemo5ValueButton(self.wg)
		self.folderButton1.setIcon(QIcon.fromTheme("general_folder"))
		self.folderButton1.setText( "MyDocs" )
		self.folderButton1.setValueText( "/home/user/MyDocs" )
		self.folderButton1.setMinimumSize(QSize(0,70))
		self.folderButton2 = QMaemo5ValueButton(self.wg)
		self.folderButton2.setIcon(QIcon.fromTheme("general_folder"))
		self.folderButton2.setText( "cooktimer" )
		self.folderButton2.setValueText( "/opt/cooktimer" )
		self.folderButton2.setMinimumSize(QSize(0,70))
		self.folderButton3 = QMaemo5ValueButton(self.wg)
		self.folderButton3.setIcon(QIcon.fromTheme("general_folder"))
		self.folderButton3.setText( "root" )
		self.folderButton3.setValueText( "/" )
		self.folderButton3.setMinimumSize(QSize(0,70))
		# add to grid
		self.grid = QGridLayout(self.wg)
		self.grid.addWidget(self.folderButton1,0,0,1,1)
		self.grid.addWidget(self.folderButton2,1,0,1,1)
		self.grid.addWidget(self.folderButton3,2,0,1,1)
		# actions
		self.connect(self.folderButton1, SIGNAL("clicked()"),parent.on_folderButton1_clicked)
		self.connect(self.folderButton1, SIGNAL("clicked()"),self.wg.close)
		self.connect(self.folderButton2, SIGNAL("clicked()"),parent.on_folderButton2_clicked)
		self.connect(self.folderButton2, SIGNAL("clicked()"),self.wg.close)
		self.connect(self.folderButton3, SIGNAL("clicked()"),parent.on_folderButton3_clicked)
		self.connect(self.folderButton3, SIGNAL("clicked()"),self.wg.close)
		# show
		self.wg.show()

class FormWidget(QWidget):
	def __init__(self, parent):
		super(FormWidget, self).__init__(parent)
		global hoursPicked1
		global minutesPicked1
		global secondsPicked1
		global hoursPicked2
		global minutesPicked2
		global secondsPicked2
		global hoursPicked3
		global minutesPicked3
		global secondsPicked3
		global msgTxtPicked1_1, msgTimePicked1_1, msgTxtPicked1_2, msgTimePicked1_2, msgTxtPicked1_3, msgTimePicked1_3
		global msgTxtPicked2_1, msgTimePicked2_1, msgTxtPicked2_2, msgTimePicked2_2, msgTxtPicked2_3, msgTimePicked2_3
		global msgTxtPicked3_1, msgTimePicked3_1, msgTxtPicked3_2, msgTimePicked3_2, msgTxtPicked3_3, msgTimePicked3_3

		# Timer1
		self.Timer1 = QTimer()
		self.Timer1.timeout.connect(self.updateTimer1)
		# Timer2
		self.Timer2 = QTimer()
		self.Timer2.timeout.connect(self.updateTimer2)
		# Timer3
		self.Timer3 = QTimer()
		self.Timer3.timeout.connect(self.updateTimer3)
	 
		font = QFont()
		font.setPointSize(48)
		startTime= QTime(0, 0, 0)  

		self.gerechtButton1 = QPushButton(self.tr("Choose dish"))
		self.gerechtButton2 = QPushButton(self.tr("Choose dish"))
		self.gerechtButton3 = QPushButton(self.tr("Choose dish"))
		self.timeButton1 = QPushButton("00:00:00")
		self.timeButton2 = QPushButton("00:00:00")
		self.timeButton3 = QPushButton("00:00:00")
		# see if we need to set default dishes
		num_lines = sum(1 for line in open(Cooktimer_StartItems))
		file = codecs.open(Cooktimer_StartItems,"r", encoding="utf-8")
		data = file.readlines()
		file.close()
		if num_lines > 0:
			f = codecs.open(Cooktimer_ItemFile,"r", encoding="utf-8")
			lines = f.readlines()
			f.close()
			for count in range(0,num_lines):
				foundInItems = False;
				for count2 in range(0,len(lines)):
					if data[count].strip()+"|" in lines[count2].strip():
						foundInItems = True
						if count == 0:
							for count3 in range(lines[count2].count('|'),5):
								# add |, make sure all can be read
								lines[count2] = lines[count2].strip() + "|"
							(msgTxtPicked1_1, msgTimePicked1_1, msgTxtPicked1_2, msgTimePicked1_2, msgTxtPicked1_3, msgTimePicked1_3) = lines[count2].split('|')
							self.gerechtButton1.setText(msgTxtPicked1_1)
							self.timeButton1.setText(msgTimePicked1_1)
						if count == 1:
							for count3 in range(lines[count2].count('|'),5):
								# add |, make sure all can be read
								lines[count2] = lines[count2].strip() + "|"
							(msgTxtPicked2_1, msgTimePicked2_1, msgTxtPicked2_2, msgTimePicked2_2, msgTxtPicked2_3, msgTimePicked2_3) = lines[count2].split('|')
							self.gerechtButton2.setText(msgTxtPicked2_1)
							self.timeButton2.setText(msgTimePicked2_1)
						if count == 2:
							for count3 in range(lines[count2].count('|'),5):
								# add |, make sure all can be read
								lines[count2] = lines[count2].strip() + "|"
							(msgTxtPicked3_1, msgTimePicked3_1, msgTxtPicked3_2, msgTimePicked3_2, msgTxtPicked3_3, msgTimePicked3_3) = lines[count2].split('|')
							self.gerechtButton3.setText(msgTxtPicked3_1)
							self.timeButton3.setText(msgTimePicked3_1)
				if not foundInItems:
					# orphaned dish, remove it
					file = codecs.open(Cooktimer_StartItems,"w", encoding="utf-8")
					data[count] = ""
					data = "".join(data)
					file.write(data)
					file.close()

		self.initDishText = self.tr("Choose dish")
		# set initial time
		self.timeRemaining1 = QPushButton("00:00:00")
		self.timeRemaining2 = QPushButton("00:00:00")
		self.timeRemaining3 = QPushButton("00:00:00")
		# set font
		self.timeRemaining1.setFont(font)
		self.timeRemaining2.setFont(font)
		self.timeRemaining3.setFont(font)
		# set start text
		self.startButton1 = QPushButton(self.tr('Start'))
		self.startButton2 = QPushButton(self.tr('Start'))
		self.startButton3 = QPushButton(self.tr('Start'))
		# set stylesheets
		self.defaultButtonColorGrey = "QPushButton {" \
			"border: 1px solid #676B67;" \
			"border-radius: 6px;" \
			"background-color: #3A3B3A;" \
			"background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 0.67, " \
				"stop: 0 #676967, stop: 1 #3A3B3A);" \
			"}" \
			"QPushButton:pressed {" \
			"border: 1px solid #333333;" \
			"background-color: #222222;" \
			"background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 0.67, " \
				"stop: 0 #444444, stop: 1 #222222);" \
		"}"
		self.defaultButtonColorGreen = "QPushButton {" \
			"border: 1px solid #199909;" \
			"border-radius: 6px;" \
			"background-color: #116a06;" \
			"background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 0.67, " \
			"stop: 0 #22c70d, stop: 1 #116a06);" \
			"}" \
			"QPushButton:pressed {" \
			"border: 1px solid #234F1D;" \
			"background-color: #143A0F;" \
			"background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 0.67, " \
			"stop: 0 #3A8930, stop: 1 #163C11);" \
			"}"
		self.defaultButtonColorRed = "QPushButton {" \
				"border: 1px solid #E81F11;" \
				"border-radius: 6px;" \
				"background-color: #95211B;" \
				"background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 0.67, " \
				"stop: 0 #FF1410, stop: 1 #95211B);" \
				"}" \
				"QPushButton:pressed {" \
				"border: 1px solid #A54841;" \
				"background-color: #502623;" \
				"background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 0.67, " \
				"stop: 0 #A12927, stop: 1 #571F1C);" \
				"}"
		self.orangeTimeRemain = "QPushButton { background : #FF6600; color : white; border-width: 1px; \
						   border-color: #FD9A59 ; border-radius: 9px; border-style: outset; }"
		self.redTimeRemain = "QPushButton { background : #8A0808; color : white; border-width: 1px; \
						   border-color: #AB0E0E ; border-radius: 9px; border-style: outset; }"
		self.greenTimeRemain = "QPushButton { background : #21610B; color : white; border-width: 1px; \
						   border-color: #3E8F23 ; border-radius: 9px; border-style: outset; }"
		self.yellowTimeRemain = "QPushButton { background : #A9881F; color : white; border-width: 1px; \
									   border-color: #9F9005 ; border-radius: 9px; border-style: outset; }"
		self.darkGreyTimeRemain = "QPushButton { color: #848484; background : #2A2B29; border-width: 1px;\
		                   border-color: black ; border-radius: 9px; border-style: inset; }"
		self.darkYellowTimeRemain = "QPushButton { color: #848484; background : #504934; border-width: 1px; \
						   border-color: #504934 ; border-radius: 9px; border-style: inset; }"
		# set stylesheets
		self.timeButton1.setStyleSheet(self.defaultButtonColorGrey)
		self.gerechtButton1.setStyleSheet(self.defaultButtonColorGrey)
		self.timeButton2.setStyleSheet(self.defaultButtonColorGrey)
		self.gerechtButton2.setStyleSheet(self.defaultButtonColorGrey)
		self.timeButton3.setStyleSheet(self.defaultButtonColorGrey)
		self.gerechtButton3.setStyleSheet(self.defaultButtonColorGrey)
		self.timeRemaining1.setStyleSheet(self.darkGreyTimeRemain)
		self.timeRemaining2.setStyleSheet(self.darkGreyTimeRemain)
		self.timeRemaining3.setStyleSheet(self.darkGreyTimeRemain)
		self.startButton1.setStyleSheet(self.defaultButtonColorGrey)
		self.startButton2.setStyleSheet(self.defaultButtonColorGrey)
		self.startButton3.setStyleSheet(self.defaultButtonColorGrey)
		# correct size of buttons
		self.gerechtButton1.setMinimumHeight(65)
		self.gerechtButton1.setMaximumHeight(65)
		self.gerechtButton2.setMinimumHeight(65)
		self.gerechtButton2.setMaximumHeight(65)
		self.gerechtButton3.setMinimumHeight(65)
		self.gerechtButton3.setMaximumHeight(65)
		self.timeButton1.setMinimumHeight(65)
		self.timeButton1.setMaximumHeight(65)
		self.timeButton2.setMinimumHeight(65)
		self.timeButton2.setMaximumHeight(65)
		self.timeButton3.setMinimumHeight(65)
		self.timeButton3.setMaximumHeight(65)
		self.startButton1.setMinimumHeight(65)
		self.startButton1.setMaximumHeight(65)
		self.startButton2.setMinimumHeight(65)
		self.startButton2.setMaximumHeight(65)
		self.startButton3.setMinimumHeight(65)
		self.startButton3.setMaximumHeight(65)
		# add to grid
		grid = QGridLayout()
		grid.addWidget(self.gerechtButton1,0,0)
		grid.addWidget(self.timeButton1,0,1)
		grid.addWidget(self.startButton1,0,2)
		grid.addWidget(self.timeRemaining1,1,0,1,3)
		grid.addWidget(self.gerechtButton2,2,0)
		grid.addWidget(self.timeButton2,2,1)
		grid.addWidget(self.startButton2,2,2)
		grid.addWidget(self.timeRemaining2,3,0,1,3)
		grid.addWidget(self.gerechtButton3,4,0)
		grid.addWidget(self.timeButton3,4,1)
		grid.addWidget(self.startButton3,4,2)
		grid.addWidget(self.timeRemaining3,5,0,1,3)
		# Disable startbuttons by default
		if self.gerechtButton1.text() != self.tr("Choose dish"):
			self.startButton1.setEnabled(True)
			self.startButton1.setStyleSheet(self.defaultButtonColorGreen)
			self.timeRemaining1.setStyleSheet(self.darkGreyTimeRemain)
			self.timeRemaining1.setText(self.timeButton1.text())
			startTime1 = self.timeRemaining1.text()
			(hoursPicked1, minutesPicked1, secondsPicked1) = startTime1.split(':')
		else:
			self.startButton1.setEnabled(False)
		if self.gerechtButton2.text() != self.tr("Choose dish"):
			self.startButton2.setEnabled(True)
			self.startButton2.setStyleSheet(self.defaultButtonColorGreen)
			self.timeRemaining2.setStyleSheet(self.darkGreyTimeRemain)
			self.timeRemaining2.setText(self.timeButton2.text())
			startTime2 = self.timeRemaining2.text()
			(hoursPicked2, minutesPicked2, secondsPicked2) = startTime2.split(':')
		else:
			self.startButton2.setEnabled(False)
		if self.gerechtButton3.text() != self.tr("Choose dish"):
			self.startButton3.setEnabled(True)
			self.startButton3.setStyleSheet(self.defaultButtonColorGreen)
			self.timeRemaining3.setStyleSheet(self.darkGreyTimeRemain)
			self.timeRemaining3.setText(self.timeButton3.text())
			startTime3 = self.timeRemaining3.text()
			(hoursPicked3, minutesPicked3, secondsPicked3) = startTime3.split(':')
		else:
			self.startButton3.setEnabled(False)
		# set minimum column width for time and start button
		grid.setColumnMinimumWidth(1, 120)
		grid.setColumnMinimumWidth(2, 120)

		self.timeRemaining1.setAutoRepeat(True)
		self.timeRemaining1.setAutoRepeatDelay(1000)
		self.timeRemaining1.setAutoRepeatInterval(1000)
		self.timeRemaining2.setAutoRepeat(True)
		self.timeRemaining2.setAutoRepeatDelay(1000)
		self.timeRemaining2.setAutoRepeatInterval(1000)
		self.timeRemaining3.setAutoRepeat(True)
		self.timeRemaining3.setAutoRepeatDelay(1000)
		self.timeRemaining3.setAutoRepeatInterval(1000)
		self.timeButton1.setAutoRepeat(True)
		self.timeButton1.setAutoRepeatDelay(1000)
		self.timeButton1.setAutoRepeatInterval(1000)
		self.timeButton2.setAutoRepeat(True)
		self.timeButton2.setAutoRepeatDelay(1000)
		self.timeButton2.setAutoRepeatInterval(1000)
		self.timeButton3.setAutoRepeat(True)
		self.timeButton3.setAutoRepeatDelay(1000)
		self.timeButton3.setAutoRepeatInterval(1000)
		self.gerechtButton1.setAutoRepeat(True)
		self.gerechtButton1.setAutoRepeatDelay(1000)
		self.gerechtButton1.setAutoRepeatInterval(1000)
		self.gerechtButton2.setAutoRepeat(True)
		self.gerechtButton2.setAutoRepeatDelay(1000)
		self.gerechtButton2.setAutoRepeatInterval(1000)
		self.gerechtButton3.setAutoRepeat(True)
		self.gerechtButton3.setAutoRepeatDelay(1000)
		self.gerechtButton3.setAutoRepeatInterval(1000)
		# Let's make something happen when the button is pushed!
		self.connect(self.startButton1, SIGNAL("clicked()"), self.startTimer1)
		self.connect(self.startButton2, SIGNAL("clicked()"), self.startTimer2)
		self.connect(self.startButton3, SIGNAL("clicked()"), self.startTimer3)
		self.gerechtButton1.clicked.connect(self.gerechtButtonClicked1)
		self.gerechtButton2.clicked.connect(self.gerechtButtonClicked2)
		self.gerechtButton3.clicked.connect(self.gerechtButtonClicked3)
		self.timeButton1.clicked.connect(self.pickedTimeClicked1)
		self.timeButton2.clicked.connect(self.pickedTimeClicked2)
		self.timeButton3.clicked.connect(self.pickedTimeClicked3)
		self.timeRemaining1.clicked.connect(self.timeClicked1)
		self.timeRemaining2.clicked.connect(self.timeClicked2)
		self.timeRemaining3.clicked.connect(self.timeClicked3)
		self._state1 = 0
		self._state2 = 0
		self._state3 = 0
	 
		# Set the layout on the window: this means that our button will actually be displayed.
		self.setLayout(grid)

	def timeClicked1(self):
		global isContinueMode1
		global isStopwatchMode1
		global isContinueMode1Restore
		global isContinueMode1Active
		global pause1
		if self.timeRemaining1.isDown():
			if self._state1 == 0:
				self._state1 = 1
				self.timeRemaining1.setAutoRepeatInterval(50)
				if not self.Timer1.isActive() and not pause1:
					isStopwatchMode1 = not isStopwatchMode1
					self.Timer1.stop()
					pause1 = False
					if isStopwatchMode1:
						stopwatchMsg = self.tr("Stopwatch mode ON")
						# dark yellow
						self.timeRemaining1.setStyleSheet(self.darkYellowTimeRemain)
						self.timeRemaining1.setText("00:00:00")
						self.timeRemaining1.setIcon(QIcon(""))
						isContinueMode1Restore = isContinueMode1
						isContinueMode1 = False
						isContinueMode1Active = False
						self.startButton1.setEnabled(True)
						self.startButton1.setText(self.tr('Start'))
						self.startButton1.setStyleSheet(self.defaultButtonColorGreen)
					else:
						# dark grey
						self.timeRemaining1.setStyleSheet(self.darkGreyTimeRemain)
						self.timeRemaining1.setText(self.timeButton1.text())
						if isContinueMode1Restore:
							isContinueMode1 = True
							self.timeRemaining1.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_grey.png"))
							stopwatchMsg = self.tr("Continue mode ON")
						else:
							stopwatchMsg = self.tr("Stopwatch mode OFF")
						self.startButton1.setText(self.tr('Start'))
						if self.timeButton1.text() == "00:00:00":
							self.startButton1.setEnabled(False)
							self.startButton1.setStyleSheet(self.defaultButtonColorGrey)
						else:
							# green
							self.startButton1.setStyleSheet(self.defaultButtonColorGreen)
					os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
						/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
						string:"'+stopwatchMsg+'"')
		elif self._state1 == 1:
			self._state1 = 0
			self.timeRemaining1.setAutoRepeatInterval(1000)
		else:
			self.togglePause1()

	def timeClicked2(self):
		global isContinueMode2
		global isStopwatchMode2
		global isContinueMode2Restore
		global isContinueMode2Active
		global pause2
		if self.timeRemaining2.isDown():
			if self._state2 == 0:
				self._state2 = 1
				self.timeRemaining2.setAutoRepeatInterval(50)
				if not self.Timer2.isActive() and not pause2:
					isStopwatchMode2 = not isStopwatchMode2
					self.Timer2.stop()
					pause2 = False
					if isStopwatchMode2:
						stopwatchMsg = self.tr("Stopwatch mode ON")
						# dark yellow
						self.timeRemaining2.setStyleSheet(self.darkYellowTimeRemain)
						self.timeRemaining2.setText("00:00:00")
						self.timeRemaining2.setIcon(QIcon(""))
						isContinueMode2Restore = isContinueMode2
						isContinueMode2 = False
						isContinueMode2Active = False
						self.startButton2.setEnabled(True)
						self.startButton2.setText(self.tr('Start'))
						self.startButton2.setStyleSheet(self.defaultButtonColorGreen)
					else:
						# dark grey
						self.timeRemaining2.setStyleSheet(self.darkGreyTimeRemain)
						self.timeRemaining2.setText(self.timeButton2.text())
						if isContinueMode2Restore:
							isContinueMode2 = True
							self.timeRemaining2.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_grey.png"))
							stopwatchMsg = self.tr("Continue mode ON")
						else:
							stopwatchMsg = self.tr("Stopwatch mode OFF")
						self.startButton2.setText(self.tr('Start'))
						if self.timeButton2.text() == "00:00:00":
							self.startButton2.setEnabled(False)
							self.startButton2.setStyleSheet(self.defaultButtonColorGrey)
						else:
							# green
							self.startButton2.setStyleSheet(self.defaultButtonColorGreen)
					os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
						/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
						string:"'+stopwatchMsg+'"')
		elif self._state2 == 1:
			self._state2 = 0
			self.timeRemaining2.setAutoRepeatInterval(1000)
		else:
			self.togglePause2()

	def timeClicked3(self):
		global isContinueMode3
		global isStopwatchMode3
		global pause3
		global isContinueMode3Active
		global isContinueMode3Restore
		if self.timeRemaining3.isDown():
			if self._state3 == 0:
				self._state3 = 1
				self.timeRemaining3.setAutoRepeatInterval(50)
				if not self.Timer3.isActive() and not pause3:
					isStopwatchMode3 = not isStopwatchMode3
					self.Timer3.stop()
					pause3 = False
					if isStopwatchMode3:
						stopwatchMsg = self.tr("Stopwatch mode ON")
						# dark yellow
						self.timeRemaining3.setStyleSheet(self.darkYellowTimeRemain)
						self.timeRemaining3.setText("00:00:00")
						self.timeRemaining3.setIcon(QIcon(""))
						isContinueMode3Restore = isContinueMode3
						isContinueMode3 = False
						isContinueMode3Active = False
						self.startButton3.setEnabled(True)
						self.startButton3.setText(self.tr('Start'))
						self.startButton3.setStyleSheet(self.defaultButtonColorGreen)
					else:
						# dark grey
						self.timeRemaining3.setStyleSheet(self.darkGreyTimeRemain)
						self.timeRemaining3.setText(self.timeButton3.text())
						if isContinueMode3Restore:
							isContinueMode3 = True
							self.timeRemaining3.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_grey.png"))
							stopwatchMsg = self.tr("Continue mode ON")
						else:
							stopwatchMsg = self.tr("Stopwatch mode OFF")
						self.startButton3.setText(self.tr('Start'))
						if self.timeButton3.text() == "00:00:00":
							self.startButton3.setEnabled(False)
							self.startButton3.setStyleSheet(self.defaultButtonColorGrey)
						else:
							# green
							self.startButton3.setStyleSheet(self.defaultButtonColorGreen)
					os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
						/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
						string:"'+stopwatchMsg+'"')
		elif self._state3 == 1:
			self._state3 = 0
			self.timeRemaining3.setAutoRepeatInterval(1000)
		else:
			self.togglePause3()

	def pickedTimeClicked1(self):
		global isStopwatchMode1
		global secondsPicked1
		global minutesPicked1
		global hoursPicked1
		global isContinueMode1
		global isContinueMode1Active
		global isContinueMode1Restore
		global pause1
		if self.timeButton1.isDown():
			if self._state1 == 0:
				self._state1 = 1
				self.timeButton1.setAutoRepeatInterval(50)
				if not isContinueMode1Active and not isStopwatchMode1:
					isContinueMode1 = not isContinueMode1
					if isContinueMode1:
						stopwatchMsg = self.tr("Continue mode ON")
						if self.timeRemaining1.styleSheet() == (self.darkGreyTimeRemain):
							self.timeRemaining1.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_grey.png"))
						else:
							self.timeRemaining1.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_white.png"))
						if pause1:
							self.timeRemaining1.setText("-"+self.timeRemaining1.text())
					else:
						stopwatchMsg = self.tr("Continue mode OFF")
						self.timeRemaining1.setIcon(QIcon(""))
						if pause1:
							self.timeRemaining1.setText(self.timeRemaining1.text()[1:])
					os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
						/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
						string:"'+stopwatchMsg+'"')
			#else:
			#	print 'repeat'
		elif self._state1 == 1:
			self._state1 = 0
			self.timeButton1.setAutoRepeatInterval(1000)
		else:
			self.setPickedTime1()

	def pickedTimeClicked2(self):
		global isStopwatchMode2
		global secondsPicked2
		global minutesPicked2
		global hoursPicked2
		global isContinueMode2
		global isContinueMode2Active
		global isContinueMode2Restore
		global pause2
		if self.timeButton2.isDown():
			if self._state2 == 0:
				self._state2 = 1
				self.timeButton2.setAutoRepeatInterval(50)
				if not isContinueMode2Active and not isStopwatchMode2:
					isContinueMode2 = not isContinueMode2
					if isContinueMode2:
						stopwatchMsg = self.tr("Continue mode ON")
						if self.timeRemaining2.styleSheet() == (self.darkGreyTimeRemain):
							self.timeRemaining2.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_grey.png"))
						else:
							self.timeRemaining2.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_white.png"))
						if pause2:
							self.timeRemaining2.setText("-"+self.timeRemaining2.text())
					else:
						stopwatchMsg = self.tr("Continue mode OFF")
						self.timeRemaining2.setIcon(QIcon(""))
						if pause2:
							self.timeRemaining2.setText(self.timeRemaining2.text()[1:])
					os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
						/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
						string:"'+stopwatchMsg+'"')
			#else:
			#	print 'repeat'
		elif self._state2 == 1:
			self._state2 = 0
			self.timeButton2.setAutoRepeatInterval(1000)
		else:
			self.setPickedTime2()

	def pickedTimeClicked3(self):
		global isStopwatchMode3
		global secondsPicked3
		global minutesPicked3
		global hoursPicked3
		global isContinueMode3
		global isContinueMode3Active
		global isContinueMode3Restore
		global pause3
		if self.timeButton3.isDown():
			if self._state3 == 0:
				self._state3 = 1
				self.timeButton3.setAutoRepeatInterval(50)
				if not isContinueMode3Active and not isStopwatchMode3:
					isContinueMode3 = not isContinueMode3
					if isContinueMode3:
						stopwatchMsg = self.tr("Continue mode ON")
						if self.timeRemaining3.styleSheet() == (self.darkGreyTimeRemain):
							self.timeRemaining3.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_grey.png"))
						else:
							self.timeRemaining3.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_white.png"))
						if pause3:
							self.timeRemaining3.setText("-"+self.timeRemaining3.text())
					else:
						stopwatchMsg = self.tr("Continue mode OFF")
						self.timeRemaining3.setIcon(QIcon(""))
						if pause3:
							self.timeRemaining3.setText(self.timeRemaining3.text()[1:])
					os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
						/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
						string:"'+stopwatchMsg+'"')
			#else:
			#	print 'repeat'
		elif self._state3 == 1:
			self._state3 = 0
			self.timeButton3.setAutoRepeatInterval(1000)
		else:
			self.setPickedTime3()

 
	def gerechtButtonClicked1(self):
		global secondsPicked1
		global minutesPicked1
		global hoursPicked1
		global dishName1
		global dishName1banner
		global currSelector
		global msgTxtPicked1_1
		global msgTimePicked1_1
		global msgTxtPicked1_2
		global msgTimePicked1_2
		global msgTxtPicked1_3
		global msgTimePicked1_3
		global isStopwatchMode1
		global isContinueMode1
		global isContinueMode1Active
		global pause1
		if self.gerechtButton1.isDown():
			self.timeRemaining1.setText("00:00:00")
			self.timeButton1.setText("00:00:00")
			(hoursPicked1, minutesPicked1, secondsPicked1) = "00:00:00".split(':')
			isStopwatchMode1 = False
			isContinueMode1 = False
			isContinueMode1Active = False
			self.timeRemaining1.setIcon(QIcon(""))
			self.startButton1.setEnabled(False)
			self.startButton1.setText(self.tr('Start'))
			self.gerechtButton1.setText(self.tr("Choose dish"))
			self.Timer1.stop()
			pause1 = False
			# dark grey
			self.timeRemaining1.setStyleSheet(self.darkGreyTimeRemain)
			self.startButton1.setStyleSheet(self.defaultButtonColorGrey)
			if self._state1 == 0:
				self._state1 = 1
				self.gerechtButton1.setAutoRepeatInterval(50)
		elif self._state1 == 1:
			self._state1 = 0
			self.timeButton1.setAutoRepeatInterval(1000)
		else:
			currSelector = 1
			dishPick = DishPickDialog(self)
			dishPick.show()
			if dishName1:
				self.gerechtButton1.setText(dishName1)
				dish_items = load_dishes(self)
				(hoursPicked1, minutesPicked1, secondsPicked1) = dish_items[dishPicked1Nbr][1][:8].split(':')
				hours = '%02d' % int(hoursPicked1)
				minutes = '%02d' % int(minutesPicked1)
				seconds = '%02d' % int(secondsPicked1)
				timestring = hours + ":" + minutes + ":" + seconds
				self.timeButton1.setText(timestring)

				xtrInfo = dish_items[dishPicked1Nbr][1]
				# | = 0: no extra info 6: all extra messages used
				for count in range(xtrInfo.count('|'),6):
					# add |, make sure all can be read
					xtrInfo = xtrInfo + "|"
				(dummy, msgTxtPicked1_1, msgTimePicked1_1, msgTxtPicked1_2, msgTimePicked1_2, msgTxtPicked1_3, msgTimePicked1_3) = xtrInfo.split('|')

				if not self.Timer1.isActive() and not pause1 and not isStopwatchMode1:
					self.timeRemaining1.setText(timestring)
					if timestring == "00:00:00":
						self.startButton1.setEnabled(False)
						self.startButton1.setStyleSheet(self.defaultButtonColorGrey)
					else:
						self.startButton1.setEnabled(True)
						self.startButton1.setStyleSheet(self.defaultButtonColorGreen)
				# clear it again
				dishName1banner = dishName1
				dishName1 = ""

	def gerechtButtonClicked2(self):
		global secondsPicked2
		global minutesPicked2
		global hoursPicked2
		global dishName2
		global dishName2banner
		global currSelector
		global msgTxtPicked2_1
		global msgTimePicked2_1
		global msgTxtPicked2_2
		global msgTimePicked2_2
		global msgTxtPicked2_3
		global msgTimePicked2_3
		global isStopwatchMode2
		global isContinueMode2
		global isContinueMode2Active
		global pause2
		if self.gerechtButton2.isDown():
			self.timeRemaining2.setText("00:00:00")
			self.timeButton2.setText("00:00:00")
			(hoursPicked2, minutesPicked2, secondsPicked2) = "00:00:00".split(':')
			isStopwatchMode2 = False
			isContinueMode2 = False
			isContinueMode2Active = False
			self.timeRemaining2.setIcon(QIcon(""))
			self.startButton2.setEnabled(False)
			self.startButton2.setText(self.tr('Start'))
			self.gerechtButton2.setText(self.tr("Choose dish"))
			self.Timer2.stop()
			pause2 = False
			# dark grey
			self.timeRemaining2.setStyleSheet(self.darkGreyTimeRemain)
			self.startButton2.setStyleSheet(self.defaultButtonColorGrey)
			if self._state2 == 0:
				self._state2 = 1
				self.gerechtButton2.setAutoRepeatInterval(50)
		elif self._state2 == 1:
			self._state2 = 0
			self.timeButton2.setAutoRepeatInterval(1000)
		else:
			currSelector = 2
			dishPick = DishPickDialog(self)
			dishPick.show()
			if dishName2:
				self.gerechtButton2.setText(dishName2)
				dish_items = load_dishes(self)
				(hoursPicked2, minutesPicked2, secondsPicked2) = dish_items[dishPicked2Nbr][1][:8].split(':')
				hours = '%02d' % int(hoursPicked2)
				minutes = '%02d' % int(minutesPicked2)
				seconds = '%02d' % int(secondsPicked2)
				timestring = hours + ":" + minutes + ":" + seconds
				self.timeButton2.setText(timestring)

				xtrInfo = dish_items[dishPicked2Nbr][1]
				# | = 0: no extra info 6: all extra messages used
				for count in range(xtrInfo.count('|'),6):
					# add |, make sure all can be read
					xtrInfo = xtrInfo + "|"
				(dummy, msgTxtPicked2_1, msgTimePicked2_1, msgTxtPicked2_2, msgTimePicked2_2, msgTxtPicked2_3, msgTimePicked2_3) = xtrInfo.split('|')

				if not self.Timer2.isActive() and not pause2 and not isStopwatchMode2:
					self.timeRemaining2.setText(timestring)
					if timestring == "00:00:00":
						self.startButton2.setEnabled(False)
						self.startButton2.setStyleSheet(self.defaultButtonColorGrey)
					else:
						self.startButton2.setEnabled(True)
						self.startButton2.setStyleSheet(self.defaultButtonColorGreen)
				# clear it again
				dishName2banner = dishName2
				dishName2 = ""

	def gerechtButtonClicked3(self):
		global secondsPicked3
		global minutesPicked3
		global hoursPicked3
		global dishName3
		global dishName3banner
		global currSelector
		global msgTxtPicked3_1
		global msgTimePicked3_1
		global msgTxtPicked3_2
		global msgTimePicked3_2
		global msgTxtPicked3_3
		global msgTimePicked3_3
		global isStopwatchMode3
		global isContinueMode3
		global isContinueMode3Active
		global pause3
		if self.gerechtButton3.isDown():
			self.timeRemaining3.setText("00:00:00")
			self.timeButton3.setText("00:00:00")
			(hoursPicked3, minutesPicked3, secondsPicked3) = "00:00:00".split(':')
			isStopwatchMode3 = False
			isContinueMode3 = False
			isContinueMode3Active = False
			self.timeRemaining3.setIcon(QIcon(""))
			self.startButton3.setEnabled(False)
			self.startButton3.setText(self.tr('Start'))
			self.gerechtButton3.setText(self.tr("Choose dish"))
			self.Timer3.stop()
			pause3 = False
			# dark grey
			self.timeRemaining3.setStyleSheet(self.darkGreyTimeRemain)
			self.startButton3.setStyleSheet(self.defaultButtonColorGrey)
			if self._state3 == 0:
				self._state3 = 1
				self.gerechtButton3.setAutoRepeatInterval(50)
		elif self._state3 == 1:
			self._state3 = 0
			self.timeButton3.setAutoRepeatInterval(1000)
		else:
			currSelector = 3
			dishPick = DishPickDialog(self)
			dishPick.show()
			if dishName3:
				self.gerechtButton3.setText(dishName3)
				dish_items = load_dishes(self)
				(hoursPicked3, minutesPicked3, secondsPicked3) = dish_items[dishPicked3Nbr][1][:8].split(':')
				hours = '%02d' % int(hoursPicked3)
				minutes = '%02d' % int(minutesPicked3)
				seconds = '%02d' % int(secondsPicked3)
				timestring = hours + ":" + minutes + ":" + seconds
				self.timeButton3.setText(timestring)

				xtrInfo = dish_items[dishPicked3Nbr][1]
				# | = 0: no extra info 6: all extra messages used
				for count in range(xtrInfo.count('|'),6):
					# add |, make sure all can be read
					xtrInfo = xtrInfo + "|"
				(dummy, msgTxtPicked3_1, msgTimePicked3_1, msgTxtPicked3_2, msgTimePicked3_2, msgTxtPicked3_3, msgTimePicked3_3) = xtrInfo.split('|')

				if not self.Timer3.isActive() and not pause3 and not isStopwatchMode3:
					self.timeRemaining3.setText(timestring)
					if timestring == "00:00:00":
						self.startButton3.setEnabled(False)
						self.startButton3.setStyleSheet(self.defaultButtonColorGrey)
					else:
						self.startButton3.setEnabled(True)
						self.startButton3.setStyleSheet(self.defaultButtonColorGreen)
				# clear it again
				dishName3banner = dishName3
				dishName3 = ""

	def startTimer1(self):
		global secondsPicked1
		global minutesPicked1
		global hoursPicked1
		global isContinueMode1Active
		global isContinueMode1
		global pause1
		if not isStopwatchMode1:
			startTime1 = str('%02d'  % int(hoursPicked1)) + ":" + str('%02d' % int(minutesPicked1)) + ":" + str('%02d' % int(secondsPicked1))
		else:
			startTime1 = self.timeRemaining1.text()
		if self.Timer1.isActive() or pause1:
			self.Timer1.stop()
			if not isStopwatchMode1:
				self.timeRemaining1.setText(self.timeButton1.text())
				if isContinueMode1:
					self.timeRemaining1.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_grey.png"))
			else:
			    self.timeRemaining1.setText("00:00:00")
			isContinueMode1Active = False
			pause1 = False
			self.startButton1.setText(self.tr('Start'))
			self.startButton1.setStyleSheet(self.defaultButtonColorGreen)
			if isStopwatchMode1:
				# dark yellow
				self.timeRemaining1.setStyleSheet(self.darkYellowTimeRemain)
			else:
				# dark grey
				self.timeRemaining1.setStyleSheet(self.darkGreyTimeRemain)
			if startTime1 == "00:00:00" and not isStopwatchMode1:
				self.startButton1.setEnabled(False)
				self.startButton1.setStyleSheet(self.defaultButtonColorGrey)
		else:
			if startTime1 != "00:00:00" or isStopwatchMode1:
				if not isStopwatchMode1:
					self.timeRemaining1.setText(self.timeButton1.text())
				self.Timer1.start(1000)
				(h, m, s) = startTime1.split(':')
				self.startSecs1 = int(h) * 3600 + int(m) * 60 + int(s)
				if not isStopwatchMode1:
					# green
					self.timeRemaining1.setStyleSheet(self.greenTimeRemain)
					if isContinueMode1:
						self.timeRemaining1.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_white.png"))
				else:
					# yellow
					self.timeRemaining1.setStyleSheet(self.yellowTimeRemain)
				self.startButton1.setText(self.tr("Stop"))
				self.startButton1.setStyleSheet(self.defaultButtonColorRed)

	def startTimer2(self):
		global secondsPicked2
		global minutesPicked2
		global hoursPicked2
		global isContinueMode2Active
		global isContinueMode2
		global pause2
		if not isStopwatchMode2:
			startTime2 = str('%02d'  % int(hoursPicked2)) + ":" + str('%02d' % int(minutesPicked2)) + ":" + str('%02d' % int(secondsPicked2))
		else:
			startTime2 = self.timeRemaining2.text()
		if self.Timer2.isActive() or pause2:
			self.Timer2.stop()
			if not isStopwatchMode2:
				self.timeRemaining2.setText(self.timeButton2.text())
				if isContinueMode2:
					self.timeRemaining2.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_grey.png"))
			else:
			    self.timeRemaining2.setText("00:00:00")
			isContinueMode2Active = False
			pause2 = False
			self.startButton2.setText(self.tr('Start'))
			self.startButton2.setStyleSheet(self.defaultButtonColorGreen)
			if isStopwatchMode2:
				# dark yellow
				self.timeRemaining2.setStyleSheet(self.darkYellowTimeRemain)
			else:
				# dark grey
				self.timeRemaining2.setStyleSheet(self.darkGreyTimeRemain)
			if startTime2 == "00:00:00" and not isStopwatchMode2:
				self.startButton2.setEnabled(False)
				self.startButton2.setStyleSheet(self.defaultButtonColorGrey)
		else:
			if startTime2 != "00:00:00" or isStopwatchMode2:
				if not isStopwatchMode2:
					self.timeRemaining2.setText(self.timeButton2.text())
				self.Timer2.start(1000)
				(h, m, s) = startTime2.split(':')
				self.startSecs2 = int(h) * 3600 + int(m) * 60 + int(s)
				if not isStopwatchMode2:
					# green
					self.timeRemaining2.setStyleSheet(self.greenTimeRemain)
					if isContinueMode2:
						self.timeRemaining2.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_white.png"))
				else:
					# yellow
					self.timeRemaining2.setStyleSheet(self.yellowTimeRemain)
				self.startButton2.setText(self.tr("Stop"))
				self.startButton2.setStyleSheet(self.defaultButtonColorRed)

	def startTimer3(self):
		global secondsPicked3
		global minutesPicked3
		global hoursPicked3
		global isContinueMode3Active
		global isContinueMode3
		global pause3
		if not isStopwatchMode3:
			startTime3 = str('%02d'  % int(hoursPicked3)) + ":" + str('%02d' % int(minutesPicked3)) + ":" + str('%02d' % int(secondsPicked3))
		else:
			startTime3 = self.timeRemaining3.text()
		if self.Timer3.isActive() or pause3:
			self.Timer3.stop()
			if not isStopwatchMode3:
				self.timeRemaining3.setText(self.timeButton3.text())
				if isContinueMode3:
					self.timeRemaining3.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_grey.png"))
			else:
			    self.timeRemaining3.setText("00:00:00")
			isContinueMode3Active = False
			pause3 = False
			self.startButton3.setText(self.tr('Start'))
			self.startButton3.setStyleSheet(self.defaultButtonColorGreen)
			if isStopwatchMode3:
				# dark yellow
				self.timeRemaining3.setStyleSheet(self.darkYellowTimeRemain)
			else:
				# dark grey
				self.timeRemaining3.setStyleSheet(self.darkGreyTimeRemain)
			if startTime3 == "00:00:00" and not isStopwatchMode3:
				self.startButton3.setEnabled(False)
				self.startButton3.setStyleSheet(self.defaultButtonColorGrey)
		else:
			if startTime3 != "00:00:00" or isStopwatchMode3:
				if not isStopwatchMode3:
					self.timeRemaining3.setText(self.timeButton3.text())
				self.Timer3.start(1000)
				(h, m, s) = startTime3.split(':')
				self.startSecs3 = int(h) * 3600 + int(m) * 60 + int(s)
				if not isStopwatchMode3:
					# green
					self.timeRemaining3.setStyleSheet(self.greenTimeRemain)
					if isContinueMode3:
						self.timeRemaining3.setIcon(QIcon("/opt/cooktimer/icons/continue_mode_white.png"))
				else:
					# yellow
					self.timeRemaining3.setStyleSheet(self.yellowTimeRemain)
				self.startButton3.setText(self.tr("Stop"))
				self.startButton3.setStyleSheet(self.defaultButtonColorRed)

	def updateTimer1(self):
		global dishName1banner
		global isContinueMode1Active
		global isStopwatchMode1
		if isContinueMode1Active or isStopwatchMode1:
			self.startSecs1 +=1
		else:
			self.startSecs1 -=1
		hhmmss_format=format_seconds_to_hhmmss(self.startSecs1)
		self.timeRemaining1.setText(hhmmss_format)
		if not isContinueMode1Active and not isStopwatchMode1:
			# act on sub actions
			if msgTimePicked1_1 == hhmmss_format:
				Alarm(self)
				bus = dbus.SessionBus()
				proxy = bus.get_object('org.freedesktop.Notifications', '/org/freedesktop/Notifications')
				interface = dbus.Interface(proxy,dbus_interface='org.freedesktop.Notifications')
				interface.Notify('Notification', 0, 'control_bluetooth_paired', "[timer 1] " + dishName1banner, msgTxtPicked1_1, [], {}, 0)
			if msgTimePicked1_2 == hhmmss_format:
				Alarm(self)
				bus = dbus.SessionBus()
				proxy = bus.get_object('org.freedesktop.Notifications', '/org/freedesktop/Notifications')
				interface = dbus.Interface(proxy,dbus_interface='org.freedesktop.Notifications')
				interface.Notify('Notification', 0, 'control_bluetooth_paired', "[timer 1] " + dishName1banner, msgTxtPicked1_2, [], {}, 0)
			if msgTimePicked1_3 == hhmmss_format:
				Alarm(self)
				bus = dbus.SessionBus()
				proxy = bus.get_object('org.freedesktop.Notifications', '/org/freedesktop/Notifications')
				interface = dbus.Interface(proxy,dbus_interface='org.freedesktop.Notifications')
				interface.Notify('Notification', 0, 'control_bluetooth_paired', "[timer 1] " + dishName1banner, msgTxtPicked1_3, [], {}, 0)

			if self.startSecs1 == 0:
				self.Timer1.stop()

				if not pause2:
					if self.Timer2.isActive():
						if isContinueMode2Active or isStopwatchMode2:
							# yellow
							self.timeRemaining2.setStyleSheet(self.yellowTimeRemain)
						else:
							# green
							self.timeRemaining2.setStyleSheet(self.greenTimeRemain)
					else:
						if isStopwatchMode2:
							# dark yellow
							self.timeRemaining2.setStyleSheet(self.darkYellowTimeRemain)
						else:
							# dark grey
							self.timeRemaining2.setStyleSheet(self.darkGreyTimeRemain)
				if not pause3:
					if self.Timer3.isActive():
						if isContinueMode3Active or isStopwatchMode3:
							# yellow
							self.timeRemaining3.setStyleSheet(self.yellowTimeRemain)
						else:
							# green
							self.timeRemaining3.setStyleSheet(self.greenTimeRemain)
					else:
						if isStopwatchMode3:
							# dark yellow
							self.timeRemaining3.setStyleSheet(self.darkYellowTimeRemain)
						else:
							# dark grey
							self.timeRemaining3.setStyleSheet(self.darkGreyTimeRemain)
				if dishName1banner == "":
					dishName1banner = "Timer 1"
				if Alarmbanner:
					printMsg(self,"<h4>" + self.tr("timer 1 ready!") + "</h4><h2>" + dishName1banner + "</h2>",10000)
				Alarm(self)
				if isContinueMode1:
					isContinueMode1Active = True
					# yellow
					self.timeRemaining1.setStyleSheet(self.yellowTimeRemain)
					self.Timer1.start()
				else:
					# red
					self.timeRemaining1.setStyleSheet(self.redTimeRemain)
					self.startButton1.setText(self.tr("Start"))
					self.startButton1.setStyleSheet(self.defaultButtonColorGreen)

	def updateTimer2(self):
		global dishName2banner
		global isContinueMode2Active
		global isStopwatchMode2
		if isContinueMode2Active or isStopwatchMode2:
			self.startSecs2 +=1
		else:
			self.startSecs2 -=1
		hhmmss_format=format_seconds_to_hhmmss(self.startSecs2)
		self.timeRemaining2.setText(hhmmss_format)
		if not isContinueMode2Active and not isStopwatchMode2:
			# act on sub actions
			if msgTimePicked2_1 == hhmmss_format:
				Alarm(self)
				bus = dbus.SessionBus()
				proxy = bus.get_object('org.freedesktop.Notifications', '/org/freedesktop/Notifications')
				interface = dbus.Interface(proxy,dbus_interface='org.freedesktop.Notifications')
				interface.Notify('Notification', 0, 'control_bluetooth_paired', "[timer 2] " + dishName2banner, msgTxtPicked2_1, [], {}, 0)
			if msgTimePicked2_2 == hhmmss_format:
				Alarm(self)
				bus = dbus.SessionBus()
				proxy = bus.get_object('org.freedesktop.Notifications', '/org/freedesktop/Notifications')
				interface = dbus.Interface(proxy,dbus_interface='org.freedesktop.Notifications')
				interface.Notify('Notification', 0, 'control_bluetooth_paired', "[timer 2] " + dishName2banner, msgTxtPicked2_2, [], {}, 0)
			if msgTimePicked2_3 == hhmmss_format:
				Alarm(self)
				bus = dbus.SessionBus()
				proxy = bus.get_object('org.freedesktop.Notifications', '/org/freedesktop/Notifications')
				interface = dbus.Interface(proxy,dbus_interface='org.freedesktop.Notifications')
				interface.Notify('Notification', 0, 'control_bluetooth_paired', "[timer 2] " + dishName2banner, msgTxtPicked2_3, [], {}, 0)

			if self.startSecs2 == 0:
				self.Timer2.stop()

				if not pause1:
					if self.Timer1.isActive():
						if isContinueMode1Active or isStopwatchMode1:
							# yellow
							self.timeRemaining1.setStyleSheet(self.yellowTimeRemain)
						else:
							# green
							self.timeRemaining1.setStyleSheet(self.greenTimeRemain)
					else:
						if isStopwatchMode1:
							# dark yellow
							self.timeRemaining1.setStyleSheet(self.darkYellowTimeRemain)
						else:
							# dark grey
							self.timeRemaining1.setStyleSheet(self.darkGreyTimeRemain)
				if not pause3:
					if self.Timer3.isActive():
						if isContinueMode3Active or isStopwatchMode3:
							# yellow
							self.timeRemaining3.setStyleSheet(self.yellowTimeRemain)
						else:
							# green
							self.timeRemaining3.setStyleSheet(self.greenTimeRemain)
					else:
						if isStopwatchMode3:
							# dark yellow
							self.timeRemaining3.setStyleSheet(self.darkYellowTimeRemain)
						else:
							# dark grey
							self.timeRemaining3.setStyleSheet(self.darkGreyTimeRemain)
				if dishName2banner == "":
					dishName2banner = "Timer 2"
				if Alarmbanner:
					printMsg(self,"<h4>" + self.tr("timer 2 ready!") + "</h4><h2>" + dishName2banner + "</h2>",10000)
				Alarm(self)
				if isContinueMode2:
					isContinueMode2Active = True
					self.timeRemaining2.setStyleSheet(self.yellowTimeRemain)
					self.Timer2.start()
				else:
					# red
					self.timeRemaining2.setStyleSheet(self.redTimeRemain)
					self.startButton2.setText(self.tr("Start"))
					self.startButton2.setStyleSheet(self.defaultButtonColorGreen)

	def updateTimer3(self):
		global dishName3banner
		global isContinueMode3Active
		global isStopwatchMode3
		if isContinueMode3Active or isStopwatchMode3:
			self.startSecs3 +=1
		else:
			self.startSecs3 -=1
		hhmmss_format=format_seconds_to_hhmmss(self.startSecs3)
		self.timeRemaining3.setText(hhmmss_format)
		if not isContinueMode3Active and not isStopwatchMode3:
			# act on sub actions
			if msgTimePicked3_1 == hhmmss_format:
				Alarm(self)
				bus = dbus.SessionBus()
				proxy = bus.get_object('org.freedesktop.Notifications', '/org/freedesktop/Notifications')
				interface = dbus.Interface(proxy,dbus_interface='org.freedesktop.Notifications')
				interface.Notify('Notification', 0, 'control_bluetooth_paired', "[timer 3] " + dishName3banner, msgTxtPicked3_1, [], {}, 0)
			if msgTimePicked3_2 == hhmmss_format:
				Alarm(self)
				bus = dbus.SessionBus()
				proxy = bus.get_object('org.freedesktop.Notifications', '/org/freedesktop/Notifications')
				interface = dbus.Interface(proxy,dbus_interface='org.freedesktop.Notifications')
				interface.Notify('Notification', 0, 'control_bluetooth_paired', "[timer 3] " + dishName3banner, msgTxtPicked3_2, [], {}, 0)
			if msgTimePicked3_3 == hhmmss_format:
				Alarm(self)
				bus = dbus.SessionBus()
				proxy = bus.get_object('org.freedesktop.Notifications', '/org/freedesktop/Notifications')
				interface = dbus.Interface(proxy,dbus_interface='org.freedesktop.Notifications')
				interface.Notify('Notification', 0, 'control_bluetooth_paired', "[timer 3] " + dishName3banner, msgTxtPicked3_3, [], {}, 0)

			if self.startSecs3 == 0:
				self.Timer3.stop()

				if not pause1:
					if self.Timer1.isActive():
						if isContinueMode1Active or isStopwatchMode1:
							# yellow
							self.timeRemaining1.setStyleSheet(self.yellowTimeRemain)
						else:
							# green
							self.timeRemaining1.setStyleSheet(self.greenTimeRemain)
					else:
						if isStopwatchMode1:
							# dark yellow
							self.timeRemaining1.setStyleSheet(self.darkYellowTimeRemain)
						else:
							# dark grey
							self.timeRemaining1.setStyleSheet(self.darkGreyTimeRemain)
				if not pause2:
					if self.Timer2.isActive():
						if isContinueMode2Active or isStopwatchMode2:
							# yellow
							self.timeRemaining2.setStyleSheet(self.yellowTimeRemain)
						else:
							# green
							self.timeRemaining2.setStyleSheet(self.greenTimeRemain)
					else:
						if isStopwatchMode2:
							# dark yellow
							self.timeRemaining2.setStyleSheet(self.darkYellowTimeRemain)
						else:
							# dark grey
							self.timeRemaining2.setStyleSheet(self.darkGreyTimeRemain)
				if dishName3banner == "":
					dishName3banner = "Timer 3"
				if Alarmbanner:
					printMsg(self,"<h4>" + self.tr("timer 3 ready!") + "</h4><h2>" + dishName3banner + "</h2>",10000)
				Alarm(self)
				if isContinueMode3:
					isContinueMode3Active = True
					self.timeRemaining3.setStyleSheet(self.yellowTimeRemain)
					self.Timer3.start()
				else:
					# red
					self.timeRemaining3.setStyleSheet(self.redTimeRemain)
					self.startButton3.setText(self.tr("Start"))
					self.startButton3.setStyleSheet(self.defaultButtonColorGreen)

	def setPickedTime1(self):
		global secondsPicked1
		global minutesPicked1
		global hoursPicked1
		global currSelector
		global pause1
		global dishName1banner
		currSelector = 1
		timePick = TimePickDialog(self)
		timePick.show()  
		hours = '%02d' % int(hoursPicked1)
		minutes = '%02d' % int(minutesPicked1)
		seconds = '%02d' % int(secondsPicked1)
		timestring = hours + ":" + minutes + ":" + seconds
		self.timeButton1.setText(timestring)
		if not self.Timer1.isActive() and not pause1 and not isStopwatchMode1:
			self.timeRemaining1.setText(timestring)
			if timestring == "00:00:00":
				self.startButton1.setEnabled(False)
				self.startButton1.setStyleSheet(self.defaultButtonColorGrey)
			else:
				self.startButton1.setEnabled(True)
				self.startButton1.setStyleSheet(self.defaultButtonColorGreen)

	def setPickedTime2(self):
		global secondsPicked2
		global minutesPicked2
		global hoursPicked2
		global currSelector
		global pause2
		global dishName2banner
		currSelector = 2
		timePick = TimePickDialog(self)
		timePick.show()  
		hours = '%02d' % int(hoursPicked2)
		minutes = '%02d' % int(minutesPicked2)
		seconds = '%02d' % int(secondsPicked2)
		timestring = hours + ":" + minutes + ":" + seconds
		self.timeButton2.setText(timestring)
		if not self.Timer2.isActive() and not pause2 and not isStopwatchMode2:
			self.timeRemaining2.setText(timestring)
			if timestring == "00:00:00":
				self.startButton2.setEnabled(False)
				self.startButton2.setStyleSheet(self.defaultButtonColorGrey)
			else:
				self.startButton2.setEnabled(True)
				self.startButton2.setStyleSheet(self.defaultButtonColorGreen)

	def setPickedTime3(self):
		global secondsPicked3
		global minutesPicked3
		global hoursPicked3
		global currSelector
		global pause3
		global dishName3banner
		currSelector = 3
		timePick = TimePickDialog(self)
		timePick.show()  
		hours = '%02d' % int(hoursPicked3)
		minutes = '%02d' % int(minutesPicked3)
		seconds = '%02d' % int(secondsPicked3)
		timestring = hours + ":" + minutes + ":" + seconds
		self.timeButton3.setText(timestring)
		if not self.Timer3.isActive() and not pause3 and not isStopwatchMode3:
			self.timeRemaining3.setText(timestring)
			if timestring == "00:00:00":
				self.startButton3.setEnabled(False)
				self.startButton3.setStyleSheet(self.defaultButtonColorGrey)
			else:
				self.startButton3.setEnabled(True)
				self.startButton3.setStyleSheet(self.defaultButtonColorGreen)

	def togglePause1(self):
		global pause1
		if self.timeRemaining1.text() != "00:00:00":
			if self.Timer1.isActive():
				self.Timer1.stop()
				self.timeRemaining1.setStyleSheet(self.orangeTimeRemain)
				pause1 = True
				if isContinueMode1Active:
					self.timeRemaining1.setText("+"+self.timeRemaining1.text())
				if isContinueMode1 and not isContinueMode1Active:
					self.timeRemaining1.setText("-"+self.timeRemaining1.text())
				if isStopwatchMode1:
					self.timeRemaining1.setText("+"+self.timeRemaining1.text())
			else:
				if pause1:
					if isContinueMode1Active or isContinueMode1:
						# remove leading sign
						self.timeRemaining1.setText(self.timeRemaining1.text()[1:])
					if isStopwatchMode1:
						self.timeRemaining1.setText(self.timeRemaining1.text()[1:])
					self.Timer1.start()
					if isContinueMode1Active or isStopwatchMode1:
						# yellow
						self.timeRemaining1.setStyleSheet(self.yellowTimeRemain)
					else:
						# green
						self.timeRemaining1.setStyleSheet(self.greenTimeRemain)
					pause1 = False
		elif Sound:
			Playbin2.set_state(gst.STATE_NULL)  # for gstreamer
			os.system("dbus-send --type=method_call --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer \
				com.nokia.mafw.extension.set_extension_property string:volume variant:uint32:"+str(defaultVolume))
			if playstate == 1:
				os.popen("dbus-send --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer com.nokia.mafw.renderer.resume")

	def togglePause2(self):
		global pause2
		if self.timeRemaining2.text() != "00:00:00":
			if self.Timer2.isActive():
				self.Timer2.stop()
				self.timeRemaining2.setStyleSheet(self.orangeTimeRemain)
				pause2 = True
				if isContinueMode2Active:
					self.timeRemaining2.setText("+"+self.timeRemaining2.text())
				if isContinueMode2 and not isContinueMode2Active:
					self.timeRemaining2.setText("-"+self.timeRemaining2.text())
				if isStopwatchMode2:
					self.timeRemaining2.setText("+"+self.timeRemaining2.text())
			else:
				if pause2:
					if isContinueMode2Active or isContinueMode2:
						# remove leading sign
						self.timeRemaining2.setText(self.timeRemaining2.text()[1:])
					if isStopwatchMode2:
						self.timeRemaining2.setText(self.timeRemaining2.text()[1:])
					self.Timer2.start()
					if isContinueMode2Active or isStopwatchMode2:
						# yellow
						self.timeRemaining2.setStyleSheet(self.yellowTimeRemain)
					else:
						# green
						self.timeRemaining2.setStyleSheet(self.greenTimeRemain)
					pause2 = False
		elif Sound:
			Playbin2.set_state(gst.STATE_NULL)  # for gstreamer
			os.system("dbus-send --type=method_call --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer \
				com.nokia.mafw.extension.set_extension_property string:volume variant:uint32:"+str(defaultVolume))
			if playstate == 1:
				os.popen("dbus-send --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer com.nokia.mafw.renderer.resume")

	def togglePause3(self):
		global pause3
		if self.timeRemaining3.text() != "00:00:00":
			if self.Timer3.isActive():
				self.Timer3.stop()
				# orange
				self.timeRemaining3.setStyleSheet(self.orangeTimeRemain)
				pause3 = True
				if isContinueMode3Active:
					self.timeRemaining3.setText("+"+self.timeRemaining3.text())
				if isContinueMode3 and not isContinueMode3Active:
					self.timeRemaining3.setText("-"+self.timeRemaining3.text())
				if isStopwatchMode3:
					self.timeRemaining3.setText("+"+self.timeRemaining3.text())
			else:
				if pause3:
					if isContinueMode3Active or isContinueMode3:
						# remove leading sign
						self.timeRemaining3.setText(self.timeRemaining3.text()[1:])
					if isStopwatchMode3:
						self.timeRemaining3.setText(self.timeRemaining3.text()[1:])
					self.Timer3.start()
					if isContinueMode3Active or isStopwatchMode3:
						# yellow
						self.timeRemaining3.setStyleSheet(self.yellowTimeRemain)
					else:
						# green
						self.timeRemaining3.setStyleSheet(self.greenTimeRemain)
					pause3 = False
		elif Sound:
			Playbin2.set_state(gst.STATE_NULL)  # for gstreamer
			os.system("dbus-send --type=method_call --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer \
				com.nokia.mafw.extension.set_extension_property string:volume variant:uint32:"+str(defaultVolume))
			if playstate == 1:
				os.popen("dbus-send --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer com.nokia.mafw.renderer.resume")

class Gstreamer_play:

	def __init__(self):
		# Setting the pulsesink's event.id to "ringtone-preview". This way, your program gets added
		# to the player group automatically without having to modify xpolicy.conf
		proplist = pa_proplist_new()
		pa_proplist_sets (proplist, "event.id", "ringtone-preview")
		self.pulsesink = gst.element_factory_make("pulsesink", "shit")

		g_object_set(c_void_p(hash(self.pulsesink)), "proplist", proplist, None)
		Playbin2.set_property("audio-sink", self.pulsesink)

		bus = Playbin2.get_bus()
		bus.add_signal_watch()
		bus.connect("message", self.on_message)

	def on_message(self, bus, message):
		t = message.type
		if t == gst.MESSAGE_EOS:
			Playbin2.set_state(gst.STATE_NULL)
			self.playmode = False
			os.system("dbus-send --type=method_call --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer \
				com.nokia.mafw.extension.set_extension_property string:volume variant:uint32:"+str(defaultVolume))
			if playstate == 1:
				os.popen("dbus-send --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer com.nokia.mafw.renderer.resume")
		elif t == gst.MESSAGE_ERROR:
			Playbin2.set_state(gst.STATE_NULL)
			err, debug = message.parse_error()
			print "Error: %s" % err, debug
			self.playmode = False

	def start(self):
		if os.path.isfile(Alarmfile):
			self.playmode = True
			Playbin2.set_property("uri", "file://" + Alarmfile)
			Playbin2.set_state(gst.STATE_PLAYING)

class TimePickDialog(QWidget):
	def __init__(self,parent):
		super(TimePickDialog, self).__init__(parent)
		self.d = QDialog(self)
		self.d.setMinimumHeight(680)
		self.d.setMaximumHeight(680)
		self.d.setWindowTitle(self.tr("| hours | minutes | seconds |"))
		self.doneButton = QPushButton(self.tr("Done"))
		hbox = QGridLayout() 
		self.horizontalLayout = QGridLayout() 
		self.hourWidget = QListWidget()
		self.minuteWidget = QListWidget()
		self.secondWidget = QListWidget()
		# performance optimalization in case widget have a uniform size
		self.hourWidget.setUniformItemSizes(True)
		self.minuteWidget.setUniformItemSizes(True)
		self.secondWidget.setUniformItemSizes(True)
		f = QFont()
		f.setPointSize(24)
		global secondsPicked0
		global minutesPicked0
		global hoursPicked0
		global secondsPicked1
		global minutesPicked1
		global hoursPicked1
		global secondsPicked2
		global minutesPicked2
		global hoursPicked2
		global secondsPicked3
		global minutesPicked3
		global hoursPicked3
		global currSelector

		for i in range(49):
			item = QListWidgetItem("%02i" % i)
			item.setFont(f)
			item.setTextAlignment(Qt.AlignCenter)
			self.hourWidget.addItem(item)

		for i in range(60):
			item = QListWidgetItem("%02i" % i)
			item.setFont(f)
			item.setTextAlignment(Qt.AlignCenter)
			self.minuteWidget.addItem(item)

		for i in range(60):
			item = QListWidgetItem("%02i" % i)
			item.setFont(f)
			item.setTextAlignment(Qt.AlignCenter)
			self.secondWidget.addItem(item)

		# set time
		if currSelector == 0:
			self.hourWidget.setCurrentRow(int(hoursPicked0))
			self.minuteWidget.setCurrentRow(int(minutesPicked0))
			self.secondWidget.setCurrentRow(int(secondsPicked0))
		if currSelector == 1:
			self.hourWidget.setCurrentRow(int(hoursPicked1))
			self.minuteWidget.setCurrentRow(int(minutesPicked1))
			self.secondWidget.setCurrentRow(int(secondsPicked1))
		if currSelector == 2:
			self.hourWidget.setCurrentRow(int(hoursPicked2))
			self.minuteWidget.setCurrentRow(int(minutesPicked2))
			self.secondWidget.setCurrentRow(int(secondsPicked2))
		if currSelector == 3:
			self.hourWidget.setCurrentRow(int(hoursPicked3))
			self.minuteWidget.setCurrentRow(int(minutesPicked3))
			self.secondWidget.setCurrentRow(int(secondsPicked3))

		self.horizontalLayout.addWidget(self.hourWidget,0,0) 
		self.horizontalLayout.addWidget(self.minuteWidget,0,1) 
		self.horizontalLayout.addWidget(self.secondWidget,0,2) 
		screenGeometry = QApplication.desktop().screenGeometry()
		if screenGeometry.width() > screenGeometry.height():
			# landscape
			self.horizontalLayout.addWidget(self.doneButton,0,3,Qt.AlignBottom)
			self.doneButton.setMinimumWidth(170)
			self.hourWidget.scrollToItem(self.hourWidget.currentItem(),QAbstractItemView.PositionAtTop)
			self.minuteWidget.scrollToItem(self.minuteWidget.currentItem(),QAbstractItemView.PositionAtTop)
			self.secondWidget.scrollToItem(self.secondWidget.currentItem(),QAbstractItemView.PositionAtTop)
		else:
			# portrait
			self.horizontalLayout.addWidget(self.doneButton,1,0,1,3)
			self.hourWidget.scrollToItem(self.hourWidget.currentItem(),QAbstractItemView.PositionAtCenter)
			self.minuteWidget.scrollToItem(self.minuteWidget.currentItem(),QAbstractItemView.PositionAtCenter)
			self.secondWidget.scrollToItem(self.secondWidget.currentItem(),QAbstractItemView.PositionAtCenter)
		self.connect(QApplication.desktop(), SIGNAL("resized(int)"), self.orientationChanged)
		self.d.setLayout(hbox)
		hbox.addLayout (self.horizontalLayout,0,0)
		self.connect(self.doneButton, SIGNAL("clicked()"), self.accept)
		self.d.exec_()

	def accept(self):
		global secondsPicked0
		global minutesPicked0
		global hoursPicked0
		global secondsPicked1
		global minutesPicked1
		global hoursPicked1
		global secondsPicked2
		global minutesPicked2
		global hoursPicked2
		global secondsPicked3
		global minutesPicked3
		global hoursPicked3
		global currSelector
		if currSelector == 0:
			hoursPicked0 = self.hourWidget.currentRow()
			minutesPicked0 = self.minuteWidget.currentRow()
			secondsPicked0 = self.secondWidget.currentRow()
		if currSelector == 1:
			hoursPicked1 = self.hourWidget.currentRow()
			minutesPicked1 = self.minuteWidget.currentRow()
			secondsPicked1 = self.secondWidget.currentRow()
		if currSelector == 2:
			hoursPicked2 = self.hourWidget.currentRow()
			minutesPicked2 = self.minuteWidget.currentRow()
			secondsPicked2 = self.secondWidget.currentRow()
		if currSelector == 3:
			hoursPicked3 = self.hourWidget.currentRow()
			minutesPicked3 = self.minuteWidget.currentRow()
			secondsPicked3 = self.secondWidget.currentRow()
		self.d.close()

	def orientationChanged(self):
		screenGeometry = QApplication.desktop().screenGeometry()
		if screenGeometry.width() > screenGeometry.height():
			# landscape
			self.d.setMinimumHeight(680)
			self.d.setMaximumHeight(680)
			self.hourWidget.scrollToItem(self.hourWidget.currentItem(),QAbstractItemView.PositionAtTop)
			self.minuteWidget.scrollToItem(self.minuteWidget.currentItem(),QAbstractItemView.PositionAtTop)
			self.secondWidget.scrollToItem(self.secondWidget.currentItem(),QAbstractItemView.PositionAtTop)
			self.horizontalLayout.removeWidget(self.doneButton)
			self.horizontalLayout.addWidget(self.doneButton,0,3,Qt.AlignBottom)
			self.doneButton.setMinimumWidth(170)
		else:
			# portrait
			self.d.resize(680,740)
			self.d.setMinimumHeight(680)
			self.d.setMaximumHeight(680)
			self.hourWidget.scrollToItem(self.hourWidget.currentItem(),QAbstractItemView.PositionAtCenter)
			self.minuteWidget.scrollToItem(self.minuteWidget.currentItem(),QAbstractItemView.PositionAtCenter)
			self.secondWidget.scrollToItem(self.secondWidget.currentItem(),QAbstractItemView.PositionAtCenter)
			self.horizontalLayout.removeWidget(self.doneButton)
			self.horizontalLayout.addWidget(self.doneButton,1,0,1,3)


class DishPickDialog(QWidget):
	def __init__(self,parent):
		super(DishPickDialog, self).__init__(parent)
		self.d = QDialog(self)
		self.d.setMinimumHeight(680)
		self.d.setMaximumHeight(680)
		self.d.setWindowTitle(self.tr("[Choose dish]"))
		hbox = QGridLayout() 
		horizontalLayout = QGridLayout() 
		self.dishWidget = QListWidget()
		self.dishWidget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

		dish_items = load_dishes(self)
		horizontalLayout.addWidget(self.dishWidget,0,0) 

		for gerecht in dish_items:
			item = QListWidgetItem(gerecht[0])
			item.setTextAlignment(Qt.AlignCenter)
			self.dishWidget.addItem(item)
			if currSelector == 1 and dishName1banner == gerecht[0]:
				item.setSelected(True)
				self.dishWidget.setCurrentItem(item)
			if currSelector == 2 and dishName2banner == gerecht[0]:
				item.setSelected(True)
				self.dishWidget.setCurrentItem(item)
			if currSelector == 3 and dishName3banner == gerecht[0]:
				item.setSelected(True)
				self.dishWidget.setCurrentItem(item)

		screenGeometry = QApplication.desktop().screenGeometry()

		self.connect(QApplication.desktop(), SIGNAL("resized(int)"), self.orientationChanged)
		self.d.setLayout(hbox)
		hbox.addLayout (horizontalLayout,0,0)

		self.connect(self.dishWidget, SIGNAL("itemClicked(QListWidgetItem *)"), self.itemClicked)
		self.d.exec_()

	def itemClicked(self, item):
		global currSelector
		global dishName1
		global dishName1banner
		global dishPicked1Nbr
		global dishName2
		global dishPicked2Nbr
		global dishName3
		global dishPicked3Nbr
		if currSelector == 1:
			dishPicked1Nbr = self.dishWidget.currentRow()
			dishName1 = item.text()
		if currSelector == 2:
			dishPicked2Nbr = self.dishWidget.currentRow()
			dishName2 = item.text()
		if currSelector == 3:
			dishPicked3Nbr = self.dishWidget.currentRow()
			dishName3 = item.text()
		self.d.close()

	def orientationChanged(self):
		screenGeometry = QApplication.desktop().screenGeometry()
		if screenGeometry.width() > screenGeometry.height():
			# landscape
			self.d.setMinimumHeight(680)
			self.d.setMaximumHeight(680)
			self.dishWidget.scrollToItem(self.dishWidget.currentItem(),QAbstractItemView.PositionAtTop)
		else:
			# portrait
			self.d.resize(680,740)
			self.d.setMinimumHeight(680)
			self.d.setMaximumHeight(680)
			self.dishWidget.scrollToItem(self.dishWidget.currentItem(),QAbstractItemView.PositionAtCenter)

class extItemWindow(QWidget):
	def __init__(self,parent):
		super(extItemWindow, self).__init__(parent)
		self.wg = QDialog(self)
		self.wg.resize(398, 360)
		self.wg.setWindowTitle(globals()['ItemName%s' % rowNbr].text())

		self.grid2 = QGridLayout()
		grid = QGridLayout()
		scrollingWidget = QWidget()
		scrollingWidget.setLayout(self.grid2)
		 
		self.myScrollArea = QScrollArea()
		self.myScrollArea.setWidgetResizable(True)
		self.myScrollArea.setEnabled(True)
		 
		self.myScrollArea.setWidget(scrollingWidget)
		hbox = QGridLayout()
		hbox.addWidget(self.myScrollArea,0,0,1,2)
		 
		# Layout
		grid = QGridLayout()
		self.wg.setLayout(hbox)
		grid.setHorizontalSpacing(0)
		grid.setVerticalSpacing(0)
		self.defaultItemCheckbox = QCheckBox(self.tr("set on start"),self)
		font = QFont()
		font.setPointSize(15)
		self.defaultItemCheckbox.setFont(font)
		self.cookHintTxt1 = QLineEdit()
		self.cookHintTxt2 = QLineEdit()
		self.cookHintTxt3 = QLineEdit()
		self.cookHintTxt1.setPlaceholderText(self.tr("Message"))
		self.cookHintTxt2.setPlaceholderText(self.tr("Message"))
		self.cookHintTxt3.setPlaceholderText(self.tr("Message"))
		hbox.addWidget(self.cookHintTxt1,0,0,1,2)
		hbox.addWidget(self.cookHintTxt2,1,0,1,2)
		hbox.addWidget(self.cookHintTxt3,2,0,1,2)
		self.cooktime1 = QMaemo5ValueButton(self.tr("time"))
		self.cooktime2 = QMaemo5ValueButton(self.tr("time"))
		self.cooktime3 = QMaemo5ValueButton(self.tr("time"))
		self.cooktime1.setValueLayout(QMaemo5ValueButton.ValueUnderTextCentered)
		self.cooktime2.setValueLayout(QMaemo5ValueButton.ValueUnderTextCentered)
		self.cooktime3.setValueLayout(QMaemo5ValueButton.ValueUnderTextCentered)
		self.cooktime1.setValueText("00:00:00")
		self.cooktime2.setValueText("00:00:00")
		self.cooktime3.setValueText("00:00:00")
		hbox.addWidget(self.cooktime1,0,2)
		hbox.addWidget(self.cooktime2,1,2)
		hbox.addWidget(self.cooktime3,2,2)
		clearButton1 = QPushButton()
		clearButton1.setMaximumWidth(50)
		clearButton1.setIcon(QIcon.fromTheme("general_delete"))
		clearButton1.setStyleSheet("background: transparent; border: none")
		clearButton2 = QPushButton()
		clearButton2.setIcon(QIcon.fromTheme("general_delete"))
		clearButton2.setStyleSheet("background: transparent; border: none")
		clearButton3 = QPushButton()
		clearButton3.setIcon(QIcon.fromTheme("general_delete"))
		clearButton3.setStyleSheet("background: transparent; border: none")
		hbox.addWidget(clearButton1,0,3)
		hbox.addWidget(clearButton2,1,3)
		hbox.addWidget(clearButton3,2,3)
		hbox.addWidget(self.defaultItemCheckbox,4,0)
		# test if we have startup dish
		startDishfile = codecs.open(Cooktimer_StartItems,"r", encoding="utf-8")
		data = startDishfile.readlines()
		startDishfile.close()
		num_lines = sum(1 for line in open(Cooktimer_StartItems))
		for count in range(0,num_lines):
			if data[count].strip() == globals()['ItemName%s' % rowNbr].text():
				self.defaultItemCheckbox.setChecked(True)
		
		alarmTxt = QLabel("<b>"+self.tr("Alarm")+"</b>")
		alarmTxt.setStyleSheet("qproperty-alignment: 'AlignCenter|AlignRight';")
		hbox.addWidget(alarmTxt,4,1)
		timetext = globals()['timeSel%s' % rowNbr].valueText()
		hbox.addWidget(QLabel("<center>"+timetext+"</center>"),4,2)
		self.saveItemButton = QPushButton(self.tr("Done"),self)
		hbox.addWidget(self.saveItemButton,5,0,1,4)
		hh_mi_ss = globals()['timeSel%s' % rowNbr].valueText().split(':',2)
		allInfo = globals()['timeSel%s' % rowNbr].statusTip().split('|')
		if len(allInfo) > 1:
			self.cookHintTxt1.setText(allInfo[1])
			self.cooktime1.setValueText(allInfo[2])
		if len(allInfo) > 3:
			self.cookHintTxt2.setText(allInfo[3])
			self.cooktime2.setValueText(allInfo[4])
		if len(allInfo) > 5:
			self.cookHintTxt3.setText(allInfo[5])
			self.cooktime3.setValueText(allInfo[6])

		self.connect(self.cooktime1, SIGNAL("clicked()"),self.TimeSel1)
		self.connect(self.cooktime2, SIGNAL("clicked()"),self.TimeSel2)
		self.connect(self.cooktime3, SIGNAL("clicked()"),self.TimeSel3)
		self.connect(clearButton1, SIGNAL("clicked()"),self.Clear1)
		self.connect(clearButton2, SIGNAL("clicked()"),self.Clear2)
		self.connect(clearButton3, SIGNAL("clicked()"),self.Clear3)
		self.connect(self.saveItemButton, SIGNAL("clicked()"),self.Saveitems)
		self.wg.exec_()

	def Clear1(self):
			self.cookHintTxt1.clear()
			self.cooktime1.setValueText("00:00:00")

	def Clear2(self):
			self.cookHintTxt2.clear()
			self.cooktime2.setValueText("00:00:00")

	def Clear3(self):
			self.cookHintTxt3.clear()
			self.cooktime3.setValueText("00:00:00")

	def TimeSel1(self):
		global secondsPicked0
		global minutesPicked0
		global hoursPicked0
		global currSelector

		currSelector = 0
		hh_mi_ss = self.cooktime1.valueText().split(':',2)
		hoursPicked0 = hh_mi_ss[0]
		minutesPicked0 = hh_mi_ss[1]
		secondsPicked0 = hh_mi_ss[2]

		timePick = TimePickDialog(self)
		timePick.show()  
		hours = '%02d' % int(hoursPicked0)
		minutes = '%02d' % int(minutesPicked0)
		seconds = '%02d' % int(secondsPicked0)
		timestring = hours + ":" + minutes + ":" + seconds
		self.cooktime1.setValueText(timestring)

	def TimeSel2(self):
		global secondsPicked0
		global minutesPicked0
		global hoursPicked0
		global currSelector

		currSelector = 0
		hh_mi_ss = self.cooktime2.valueText().split(':',2)
		hoursPicked0 = hh_mi_ss[0]
		minutesPicked0 = hh_mi_ss[1]
		secondsPicked0 = hh_mi_ss[2]

		timePick = TimePickDialog(self)
		timePick.show()  
		hours = '%02d' % int(hoursPicked0)
		minutes = '%02d' % int(minutesPicked0)
		seconds = '%02d' % int(secondsPicked0)
		timestring = hours + ":" + minutes + ":" + seconds
		self.cooktime2.setValueText(timestring)

	def TimeSel3(self):
		global secondsPicked0
		global minutesPicked0
		global hoursPicked0
		global currSelector

		currSelector = 0
		hh_mi_ss = self.cooktime3.valueText().split(':',2)
		hoursPicked0 = hh_mi_ss[0]
		minutesPicked0 = hh_mi_ss[1]
		secondsPicked0 = hh_mi_ss[2]

		timePick = TimePickDialog(self)
		timePick.show()  
		hours = '%02d' % int(hoursPicked0)
		minutes = '%02d' % int(minutesPicked0)
		seconds = '%02d' % int(secondsPicked0)
		timestring = hours + ":" + minutes + ":" + seconds
		self.cooktime3.setValueText(timestring)

	def Saveitems(self):
		total_time = int(globals()['timeSel%s' % rowNbr ].valueText().replace(":", ""))
		subtime1 = int(self.cooktime1.valueText().replace(":", ""))
		subtime2 = int(self.cooktime2.valueText().replace(":", ""))
		subtime3 = int(self.cooktime3.valueText().replace(":", ""))
		if ( subtime1 >= total_time or subtime2 >= total_time or subtime3 >= total_time ):
			timeMsg = self.tr("Message time larger then alarm time!")
			os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
				/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
				string:"'+timeMsg+'"')
			return
		try:
			file = codecs.open(Cooktimer_ItemFile,"r", encoding="utf-8")
		except:
			QMessageBox.critical(self, "Warning",  "Cannot read " + Cooktimer_ItemFile)	
		# read a list of lines into data
		data = file.readlines()
		data.sort(lambda a, b: cmp(a.upper(), b.upper()))
		file.close()
		num_lines = sum(1 for line in open(Cooktimer_ItemFile))
		newItemFile = codecs.open(Cooktimer_ItemFile,"r", encoding="utf-8")
		for count in range(1,num_lines+1):
			if count == rowNbr:
				newLine = globals()['ItemName%s' % rowNbr ].text() + "|" + globals()['timeSel%s' % rowNbr ].valueText()
				if (self.cooktime1.valueText() != "00:00:00" and self.cookHintTxt1.text() != "" ):
					newLine = newLine + "|" + self.cookHintTxt1.text() + "|" + self.cooktime1.valueText()
				if (self.cooktime2.valueText() != "00:00:00" and self.cookHintTxt2.text() != "" ):
					newLine = newLine + "|" + self.cookHintTxt2.text() + "|" + self.cooktime2.valueText()
				if (self.cooktime3.valueText() != "00:00:00" and self.cookHintTxt3.text() != "" ):
					newLine = newLine + "|" + self.cookHintTxt3.text() + "|" + self.cooktime3.valueText()
				data[rowNbr-1] = newLine + "\n"
		newItemFile.close()
		try:
			file = codecs.open(Cooktimer_ItemFile,"w", encoding="utf-8")
		except:
			QMessageBox.critical(self, "Warning",  "Cannot write " + Cooktimer_ItemFile)	
		newTip = "|".join(data[rowNbr-1].split("|")[1:]).replace("\n", "")+"\n"
		globals()['timeSel%s' % rowNbr].setStatusTip(newTip)
		data = "".join(data)
		file.write(data)
		file.close()
		# update startup dishes
		# we only store the dishname
		newLine = newLine.split("|")[0].strip()
		file = codecs.open(Cooktimer_StartItems,"r", encoding="utf-8")
		data = file.readlines()
		num_lines = len(data)
		file.close()
		if num_lines == 0 and self.defaultItemCheckbox.isChecked():
				# file is empty, just write the entry
				file = codecs.open(Cooktimer_StartItems,"a", encoding="utf-8")
				file.write(newLine + "\n")
				file.close()
		if num_lines > 0 and num_lines < 3 and self.defaultItemCheckbox.isChecked():
			# we can append if dish does not exits
			match = False
			for count in range(0,num_lines):
				# match the dish itself
				if data[count].strip() == newLine:
					match = True
			if not match:
				file.close()
				file = codecs.open(Cooktimer_StartItems,"a", encoding="utf-8")
				file.write(newLine + "\n")

			file.close()
		if num_lines > 2 and self.defaultItemCheckbox.isChecked():
			presetMsg = self.tr("Max of 3 presets already used!")
			os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
				/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
				string:"'+presetMsg+'"')
			return
		if not self.defaultItemCheckbox.isChecked():
			# check if dish should be removed
			for count in range(0,num_lines):
				# match the dish itself
				if data[count].strip() == newLine:
					data[count] = ""
					file = codecs.open(Cooktimer_StartItems,"w", encoding="utf-8")
					data = "".join(data)
					file.write(data)
					file.close()
		
		saveMsg = self.tr("Messages are successfully saved")
		os.system('run-standalone.sh dbus-send --type=method_call --dest=org.freedesktop.Notifications  \
			/org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint \
			string:"'+saveMsg+'"')
		self.wg.close()
 
if __name__ == '__main__':
	# QApplication controls things relating to a Qt application, like the main loop.
	# You should always instantiate it before using any QtGui related stuff.
	# See also:
	#   http://doc.trolltech.com/4.6/qapplication.html
	#import sys
	#from PySide.QtCore import QString
	app = QApplication(sys.argv)

	# Internationalization
	# QLocale does not work as it should when having separate device/language settings
	# locale = QLocale.system().name()
	locale = os.getenv('LANG')
	appTranslator = QTranslator()
	if appTranslator.load("/opt/cooktimer/translations/cooktimer_" + locale):
		app.installTranslator(appTranslator)
		QLocale.setDefault(locale)
		print 'Language file: ' + locale + ' loaded'
	else:
		print 'Language file: ' + locale + ' not found'
	#
	# Create an instance (calling __init__, too, of course) of our window subclassing QWidget
	w = MyMainWindow()
	# Show our window
	w.show()
	# Main event loop of Qt. This won't return until the program exits.
	app.exec_()
	sys.exit()
