#!/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-20"
Vibration = False
Sound = False
Wakeup = False
Alarmbanner = False
Backlight = False
Ledblink = 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
    # display blinking led for 10 seconds
    if Ledblink:
        os.system("(dbus-send --system --type=method_call --dest=com.nokia.mce /com/nokia/mce/request com.nokia.mce.request.req_led_pattern_activate string:PatternError;sleep 10;dbus-send --system --type=method_call --dest=com.nokia.mce /com/nokia/mce/request com.nokia.mce.request.req_led_pattern_deactivate string:PatternError)&")
    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("ledblink false\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
            ledblinkset = 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
                if 'ledblink' in line:
                    ledblinkset = 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 or not ledblinkset:
                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")
                if not ledblinkset:
                    ConfigFile.write("ledblink false\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 Ledblink
        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
        if self.cooktimer_opts["ledblink"] == "true":
            Ledblink = 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"
        if Ledblink:
            self.cooktimer_opts["ledblink"] = "true"
        else: self.cooktimer_opts["ledblink"] = "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.ledCheckbox = QCheckBox(self.tr("Led blink 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)
        if Ledblink:
            self.ledCheckbox.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"
        if Ledblink:
            self.cooktimer_opts["ledblink"] = "true"
        else: self.cooktimer_opts["ledblink"] = "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 Ledblink
        global Backlight
        global Volume
        if self.screenwakeupCheckbox.isChecked():
            Wakeup = True
        else: Wakeup = False
        if self.bannerCheckbox.isChecked():
            Alarmbanner = True
        else: Alarmbanner = False
        if self.ledCheckbox.isChecked():
            Ledblink = True
        else: Ledblink = 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.ledCheckbox)
            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.ledCheckbox,3,1)
            self.grid.addWidget(self.volLabel,4,0)
            self.grid.addWidget(self.volSlider,4,1)
            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.ledCheckbox)
            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.ledCheckbox,6,0)
            self.grid.addWidget(self.volLabel,7,0)
            self.grid.addWidget(self.volSlider,8,0)
            self.grid.addWidget(self.saveConfigButton,9,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 dishName1banner
        global dishName2banner
        global dishName3banner
        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()
            rewriteFile = False
            for count in range(0,num_lines):
                foundInItems = False
                for count2 in range(0,len(lines)):
                    if  data[count].strip() == lines[count2].split("|")[0]:
                        foundInItems = True
                if not foundInItems:
                    rewriteFile = True
                    # orphaned dish, remove it
                    data[count] = ""
            if rewriteFile:
                file = codecs.open(Cooktimer_StartItems,"w", encoding="utf-8")
                data = "".join(data)
                file.write(data)
                file.close()
        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):
                for count2 in range(0,len(lines)):
                    if  data[count].strip() == lines[count2].split("|")[0]:
                        if count == 0:
                            lines[count2] = lines[count2].strip()
                            for count3 in range(lines[count2].count('|'),7):
                                lines[count2] = lines[count2] + "|"
                            (dishName1banner, timestring, msgTxtPicked1_1, msgTimePicked1_1, msgTxtPicked1_2, msgTimePicked1_2, msgTxtPicked1_3, msgTimePicked1_3) = lines[count2].split('|')
                            self.gerechtButton1.setText(dishName1banner)
                            self.timeButton1.setText(timestring)
                        if count == 1:
                            lines[count2] = lines[count2].strip()
                            for count3 in range(lines[count2].count('|'),7):
                                lines[count2] = lines[count2] + "|"
                            (dishName2banner, timestring, msgTxtPicked2_1, msgTimePicked2_1, msgTxtPicked2_2, msgTimePicked2_2, msgTxtPicked2_3, msgTimePicked2_3) = lines[count2].split('|')
                            self.gerechtButton2.setText(dishName2banner)
                            self.timeButton2.setText(timestring)
                        if count == 2:
                            lines[count2] = lines[count2].strip()
                            for count3 in range(lines[count2].count('|'),7):
                                lines[count2] = lines[count2] + "|"
                            (dishName3banner, timestring, msgTxtPicked3_1, msgTimePicked3_1, msgTxtPicked3_2, msgTimePicked3_2, msgTxtPicked3_3, msgTimePicked3_3) = lines[count2].split('|')
                            self.gerechtButton3.setText(dishName3banner)
                            self.timeButton3.setText(timestring)

        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
            msgTxtPicked1_1 = ""
            msgTimePicked1_1 = ""
            msgTxtPicked1_2 = ""
            msgTimePicked1_2 = ""
            msgTxtPicked1_3 = ""
            msgTimePicked1_3 = ""
            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
            msgTxtPicked2_1 = ""
            msgTimePicked2_1 = ""
            msgTxtPicked2_2 = ""
            msgTimePicked2_2 = ""
            msgTxtPicked2_3 = ""
            msgTimePicked2_3 = ""
            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
            msgTxtPicked3_1 = ""
            msgTimePicked3_1 = ""
            msgTxtPicked3_2 = ""
            msgTimePicked3_2 = ""
            msgTxtPicked3_3 = ""
            msgTimePicked3_3 = ""
            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():
            match = False
            for count in range(0,num_lines):
                # match the dish itself
                if data[count].strip() == newLine:
                    match = True
            if not match:
                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()
