#from classes.menuscreen import MenuScreen
import re
from kivy.uix.relativelayout import RelativeLayout

from classes.clockscreen import ClockScreen
from classes.mytextinput import MyTextInput
from classes.passwordscreen import PasswordScreen
from classes.settingscreen import SettingScreen

import MySQLdb
from kivy.config import ConfigParser
from kivy.app import App
from kivy.lang import Builder
from kivy.uix.anchorlayout import AnchorLayout
from kivy.uix.behaviors import ButtonBehavior
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.uix.checkbox import CheckBox
from kivy.uix.gridlayout import GridLayout
from kivy.uix.image import Image
from kivy.uix.label import Label
from functools import partial
from kivy.uix.modalview import ModalView
from kivy.uix.popup import Popup
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.uix.spinner import Spinner
from kivy.uix.tabbedpanel import TabbedPanel, TabbedPanelHeader, TabbedPanelItem
from kivy.uix.textinput import TextInput
from kivy.uix.vkeyboard import VKeyboard
from kivy.uix.widget import Widget
from math import sin, cos, pi
from subprocess import call
from kivy.uix.dropdown import DropDown
import commands
import threading


from wifi import Scheme, Cell
import string

import subprocess
from kivy.properties import BooleanProperty, NumericProperty, StringProperty, ListProperty, ObjectProperty, DictProperty
from kivy.clock import Clock, mainthread
import time
from KivyCalendar import DatePicker,CalendarWidget, calendar_data
# from datetime import datetime, date, timedelta
from os import path, system, listdir, execv
from sys import argv, exit

from datetime import datetime

from subprocess import PIPE, Popen

from activateAlarm import activateAlarm
from deactivateAlarm import deactivateAlarm
from fetchAlarm import fetchAlarm
# from getWebPassword import getWebPassword
from updatePassword import updatePassword
from verifyClient import verifyClient
from classes.LanguageConversion import LanguageConversion
from buzzer import buzzer

from fetchingDevices import fetchingDevices

import os


import json
stopper = False
alive = False
stop = threading.Event()

runflag = False
popup = None
globalTimer = 0
checkNetworkFlag = True
buzzerActive = False

serverOK = False
# import wx

burglaryTimerList = []

globalUser = "smart"

globalIpAddress = None
# englishLanguageDict = { "Timer": "Timer", "Ethernet": "Ethernet", "and": "and", "Wifi": "WiFi",
#                         "Settings": "Settings", "Server": "Server", "Security": "Security",
#                         "Radio": "Radio", "Alarm": "Alarm", "Types": "Types",
#                         "Firmware": "Firmware", "Mail": "Mail", "Clock": "Clock",
#                         "Date": "Date", "Burglary": "Burglary", "Language": "Language"}



class Test(TabbedPanel):
    ip = ObjectProperty(None)
    gateway = ObjectProperty(None)
    netmask = ObjectProperty(None)
    password = ObjectProperty(None)
    checkbox = ObjectProperty(None)

    def ModifyPasswordtext(self,text):
        pass


    def __init__(self,**kwargs):
        super(Test,self).__init__(**kwargs)
        self.do_default_tab = False

class AlarmScreen(Screen):
    burglaryCheckBox = ObjectProperty()
    screenLabel = ObjectProperty()
    flameText = ObjectProperty()
    burglaryText = ObjectProperty()
    waterText = ObjectProperty()
    gasText = ObjectProperty()

    def __init__(self, **kwargs):
        super(AlarmScreen, self).__init__(**kwargs)
        self.objectList = [self.screenLabel, self.flameText, self.burglaryText,
                           self.waterText, self.gasText]

        # self.conversion = LanguageConversion(objectList=self.objectList)


class Calendar(CalendarWidget):
    def __init__(self, **kwargs):
        print "CHALA CHAL"
        super(Calendar,self).__init__(**kwargs)

    def get_btn_value(self, inst):
        CalendarWidget.get_btn_value(self, inst)
        print "PRESSED"
        myAlarmAppObj.clockscreen.dateSet()

class SecurityScreen(Screen):
    screenLabel = ObjectProperty()
    changePinText = ObjectProperty()
    changeWebPinText = ObjectProperty()

    def __init__(self, **kwargs):
        super(SecurityScreen, self).__init__(**kwargs)
        self.objectList = [self.screenLabel, self.changePinText, self.changeWebPinText]
        # self.conversion = LanguageConversion(objectList=self.objectList)


class ChangePinScreen(Screen):
    oldtext = ObjectProperty()
    newtext = ObjectProperty()
    confirmtext = ObjectProperty()
    screenLabel = ObjectProperty()
    oldTextLabel = ObjectProperty()
    newTextLabel = ObjectProperty()
    confirmTextLabel = ObjectProperty()
    saveText = ObjectProperty()
    clearText = ObjectProperty()

    def __init__(self, **kwargs):
        super(ChangePinScreen, self).__init__(**kwargs)
        self.objectList = [self.screenLabel, self.oldTextLabel, self.newTextLabel,
                           self.confirmTextLabel, self.saveText, self.clearText]
        # self.conversion = LanguageConversion(objectList=self.objectList)



class ChangeWebPinScreen(Screen):
    oldtext = ObjectProperty()
    newtext = ObjectProperty()
    confirmtext = ObjectProperty()

    screenLabel = ObjectProperty()
    oldTextLabel = ObjectProperty()
    newTextLabel = ObjectProperty()
    confirmTextLabel = ObjectProperty()
    saveText = ObjectProperty()
    clearText = ObjectProperty()

    def __init__(self, **kwargs):
        super(ChangeWebPinScreen, self).__init__(**kwargs)
        self.objectList = [self.screenLabel, self.oldTextLabel, self.newTextLabel,
                           self.confirmTextLabel, self.saveText, self.clearText]

    def changeWebPassword(self):
            global globalUser
        # oldWebPassword = getWebPassword("test")
        # if oldWebPassword == self.oldtext.text:
            # self.npwd = self.newtext
            # self.npwd1 = self.confirmtext
            print self.oldtext.text, self.newtext.text, self.confirmtext.text
            if self.oldtext.text == self.newtext.text:
                content = BoxLayout(orientation='vertical')#, on_touch_down=self.dismiss_popup)
                content_cancel = Button(text='OK', size_hint_y=None, height=40)
                content_label = Label(text="Password must differ from Old Password !!!")
                content.add_widget(content_label)
                content.add_widget(content_cancel)

                popup = Popup(title='Error',
                              size_hint=(None, None), size=(400, 200),
                              content=content, disabled=False, auto_dismiss=True)
                content_cancel.bind(on_release=popup.dismiss)
                ########################################################################
                ### LANGUAGE HANDLING ###
                #########################
                conversion = LanguageConversion()
                if myAlarmAppObj.language.lspnr.text == "English":
                    languageDict = conversion.englishLanguageDict
                elif myAlarmAppObj.language.lspnr.text == "Norwegian":
                    languageDict = conversion.norwainLanguageDict

                objectList = [content_label, content_cancel, popup]
                conversion.languageConversion(objectList, languageDict)

                #########################################################################
                popup.open()
                self.ClearAll()
                return

            elif len(self.newtext.text) < 4:
                content = BoxLayout(orientation='vertical')#, on_touch_down=self.dismiss_popup)
                content_cancel = Button(text='OK', size_hint_y=None, height=40)
                content_label = Label(text='Password must be at least four characters long!!!')
                content.add_widget(content_label)
                content.add_widget(content_cancel)
                popup = Popup(title='Error',
                              size_hint=(None, None), size=(400, 200),
                              content=content, disabled=False, auto_dismiss=True)
                content_cancel.bind(on_release=popup.dismiss)

                ########################################################################
                ### LANGUAGE HANDLING ###
                #########################
                conversion = LanguageConversion()
                if myAlarmAppObj.language.lspnr.text == "English":
                    languageDict = conversion.englishLanguageDict
                elif myAlarmAppObj.language.lspnr.text == "Norwegian":
                    languageDict = conversion.norwainLanguageDict

                objectList = [content_label, content_cancel, popup]
                conversion.languageConversion(objectList, languageDict)

                #########################################################################

                popup.open()
                self.ClearAll()

                return

            elif self.newtext.text != self.confirmtext.text:
                content = BoxLayout(orientation='vertical')#, on_touch_down=self.dismiss_popup)
                content_cancel = Button(text='OK', size_hint_y=None, height=40)
                content_label = Label(text="Password didn't match!!! Try Again")
                content.add_widget(content_label)
                content.add_widget(content_cancel)
                popup = Popup(title='Error',
                              size_hint=(None, None), size=(400, 200),
                              content=content, disabled=False, auto_dismiss=True)
                content_cancel.bind(on_release=popup.dismiss)

                ########################################################################
                ### LANGUAGE HANDLING ###
                #########################
                conversion = LanguageConversion()
                if myAlarmAppObj.language.lspnr.text == "English":
                    languageDict = conversion.englishLanguageDict
                elif myAlarmAppObj.language.lspnr.text == "Norwegian":
                    languageDict = conversion.norwainLanguageDict

                objectList = [content_label, content_cancel, popup]
                conversion.languageConversion(objectList, languageDict)

                #########################################################################

                popup.open()
                self.ClearAll()
                return


            try:
                passwordStatus = updatePassword(self.oldtext.text, self.newtext.text, globalUser)
                print "passwordStatus: ", passwordStatus
                if passwordStatus == "Invalid old password":
                    myAlarmAppObj.errorPopup("Invalid Password")
                    return
            except:
                myAlarmAppObj.errorPopup("Check you Internet Connection")
                return
        # return
            # self.update_Details(self.npwd)
            # self.get_password_from_db()

            myAlarmAppObj.root.current = "securityscreen"
            self.ClearAll()

            # else:
            #     content = BoxLayout(orientation='vertical', on_touch_down=self.dismiss_popup)
            #     content_cancel = Button(text='OK', size_hint_y=None, height=40)
            #     content_label = Label(text="Password didn't match!!! Try Again")
            #     content.add_widget(content_label)
            #     content.add_widget(content_cancel)
            #     popup = Popup(title='Error',
            #                   size_hint=(None, None), size=(400, 200),
            #                   content=content, disabled=False, auto_dismiss=True)
            #     content_cancel.bind(on_release=popup.dismiss)
            #
            #     ########################################################################
            #     ### LANGUAGE HANDLING ###
            #     #########################
            #     conversion = LanguageConversion()
            #     if myAlarmAppObj.language.lspnr.text == "English":
            #         languageDict = conversion.englishLanguageDict
            #     elif myAlarmAppObj.language.lspnr.text == "Norwegian":
            #         languageDict = conversion.norwainLanguageDict
            #
            #     objectList = [content_label, content_cancel, popup]
            #     conversion.languageConversion(objectList, languageDict)
            #
            #     #########################################################################
            #
            #     popup.open()
            #     self.ClearAll()

    def dismiss_popup(self):
        popup.dismiss()

    def ClearAll(self):
        self.oldtext.text = self.newtext.text = self.confirmtext.text = ""

class EthernetandSettings(Screen):
    pass

class ServerSettings(Screen):
    screenLabel = ObjectProperty()
    macAddressTextLabel = ObjectProperty()
    serverAddressTextLabel = ObjectProperty()
    passwordTextLabel = ObjectProperty()
    testServerText = ObjectProperty()

    serverAddressText = ObjectProperty()
    passwordText = ObjectProperty()

    def __init__(self, **kwargs):
        global serverOK
        super(ServerSettings, self).__init__(**kwargs)
        self.objectList = [self.screenLabel, self.macAddressTextLabel, self.serverAddressTextLabel,
                           self.passwordTextLabel, self.testServerText]
        if serverOK:
            self.testServerText.text = "Connected"
            db = MySQLdb.connect("127.0.0.1", "root", "1234", "appdb")
            cursor = db.cursor()
            cursor.execute("SELECT * from serverTable")
            data = cursor.fetchone()
            # print "SERVER ALL", data
            db.close()
            self.serverAddressText.text = data[1]
            self.passwordText.text = data[2]


    def testServer(self):
        global serverOK
        serverAddress = self.serverAddressText.text
        password = self.passwordText.text

        print "serverAddress: %s, password: %s" % (serverAddress, password)

        serverStatus = verifyClient(serverAddress, password)

        print "serverStatus: ", serverStatus

        if serverStatus == "success":
            serverOK = True
            self.changeServerStatus()
            self.testServerText.text = "Connected"
        elif serverStatus == "fail":
            myAlarmAppObj.errorPopup("Invalid Credentials")

        elif serverStatus == "serverFailure":
            myAlarmAppObj.errorPopup("Check you Internet Connection")


    def changeServerStatus(self):
        db = MySQLdb.connect("127.0.0.1", "root", "1234", "appdb")
        cursor = db.cursor()
        cursor.execute("UPDATE serverTable SET connected=1 WHERE connected=0")
        cursor.execute("UPDATE serverTable SET serverAddress='%s' WHERE connected=1" % (self.serverAddressText.text))
        cursor.execute("UPDATE serverTable SET password='%s' WHERE connected=1" % (self.passwordText.text))
        db.commit()
        db.close()

class RadioScreen(Screen):
    pass

class FirmwareScreen(Screen):

    firmwareVersion = ObjectProperty()
    downloadComplete = False

    screenLabel = ObjectProperty()
    checkUpdatesText = ObjectProperty()


    def __init__(self, **kwargs):
        super(FirmwareScreen,self).__init__(**kwargs)
        self.version = self.checkVersion()
        # with open("version.txt") as f:
        #     self.version = f.read()
        self.firmwareVersion.text += self.version
        print "self.firmwareVersion.text 1", self.firmwareVersion.text

        self.objectList = [self.screenLabel, self.firmwareVersion, self.checkUpdatesText]
        self.updater = False

    def checkVersion(self):
        db = MySQLdb.connect("127.0.0.1", "root", "1234", "appdb")
        cursor = db.cursor()
        cursor.execute("SELECT * from versionTable")
        data = cursor.fetchone()[0]
        # print "Version", data
        db.close()
        return data

    def updateVersionInDatabase(self):
        db = MySQLdb.connect("127.0.0.1", "root", "1234", "appdb")
        cursor = db.cursor()
        cursor.execute("UPDATE versionTable SET version='%s' WHERE version='%s'" % (self.newVersion, self.version))
        db.commit()
        # print "Version", data

        db.close()


    def downloadingUpdate(self):
        # newVersionFound = False
        versionCommand = commands.getoutput("wget http://www.lelodelo.co.nf/versionUpdate.txt || echo 'ERROR'")[-5:]
        # print "versionCommand: ", versionCommand
        if versionCommand == "ERROR":
            self.downloadComplete = True
            popup.title = "Download Failed"
            self.content_label.text = "Check your Internet Connection."
            self.content_cancel.text = "Finish"
            return
        else:
            with open("versionUpdate.txt") as f:
                self.newVersion = f.read()

            print "newVersion:", self.newVersion, self.version
            if self.newVersion == self.version:
                self.downloadComplete = True
                popup.title = "Download Complete"
                self.content_label.text = "Software is Up to Date"
                self.content_cancel.text = "Finish"
                commands.getoutput("rm versionUpdate.txt")
                return

            elif "<html>" in self.newVersion:
                self.downloadComplete = True
                popup.title = "Error"
                self.content_label.text = "Download Error"
                self.content_cancel.text = "Finish"
                return

        a = commands.getoutput("wget http://www.lelodelo.co.nf/python123.tar || echo 'ERROR'")[-5:]

        if a == "ERROR":
            self.downloadComplete = True
            popup.title = "Download Failed"
            self.content_label.text = "Check your Internet Connection"
            self.content_cancel.text = "Finish"

        else:
            self.downloadComplete = True
            self.content_label.text = "Download Complete."
            self.content_cancel.text = "Reboot"
            commands.getoutput("tar -xvf python123.tar")
            commands.getoutput("rm python123.tar")

        # with open("version.txt", 'w') as f:
        #     f.write(self.newVersion)
        self.updateVersionInDatabase()
        commands.getoutput("rm versionUpdate.txt")

        # self.firmwareVersion.text = self.firmwareVersion.text.split('[/b]')[0] + '[/b]' + self.newVersion
        # self.firmwareVersion.text = self.firmwareVersion.text[:-len(self.version)] + newVersion
        # print "self.firmwareVersion.text 2", self.firmwareVersion.text

    def checkUpdates(self):

        def updatingLabel():
            # print "ENTERED"
            while not self.downloadComplete:
                for i in range(6):
                    if self.downloadComplete:
                        print "THREAD OVER"
                        self.updater = True
                        break
                    self.content_label.text = "Downloading " + "."*i
                    time.sleep(0.8)

        def langUpdater():
            while not self.updater:
                # print "RUNNING"
                ########################################################################
                ### LANGUAGE HANDLING ###
                #########################
                conversion = LanguageConversion()
                if myAlarmAppObj.language.lspnr.text == "English":
                    languageDict = conversion.englishLanguageDict
                elif myAlarmAppObj.language.lspnr.text == "Norwegian":
                    languageDict = conversion.norwainLanguageDict

                objectList = [self.content_label, self.content_cancel, popup]
                conversion.languageConversion(objectList, languageDict)

                #########################################################################

        global popup
        content = BoxLayout(orientation='vertical')
        self.content_cancel = Button(text='Cancel', size_hint_y=None, height=40)
        self.content_label = Label(text='Downloading')#, pos=(0,0), background_color=(0.7,0.7,1,1))
        self.content_cancel.bind(on_release=self.popupDismiss)
        # with open("version.txt") as f:
        #     self.version = f.read()

        print self.version
        content.add_widget(self.content_label)
        content.add_widget(self.content_cancel)
        popup = Popup(title='Checking For Updates',
                      size_hint=(None, None), size=(300, 200),
                      content=content, disabled=False, auto_dismiss=False)
        threading.Thread(target=updatingLabel).start()
        threading.Thread(target=self.downloadingUpdate).start()
        threading.Thread(target=langUpdater).start()


        popup.open()

    def popupDismiss(self, e):
        global popup
        popup.dismiss()
        self.downloadComplete = True


class MailScreen(Screen):
    pass

class BurglaryAlarm(Screen):
    pass

class LanguageScreen(Screen):
    screenLabel = ObjectProperty()
    lspnr = ObjectProperty()

    def __init__(self, **kwargs):
        super(LanguageScreen, self).__init__(**kwargs)
        self.objectList = [self.screenLabel]


class Screen_Manager(ScreenManager):
    pass

class EthernetWifi(Screen):
    ipg = ObjectProperty()
    screenLabel = ObjectProperty()
    wifiText = ObjectProperty()
    ethernetText = ObjectProperty()

    def __init__(self, **kwargs):
        super(EthernetWifi, self).__init__(**kwargs)
        self.objectList = [self.screenLabel, self.wifiText, self.ethernetText]


class WifiLabel(BoxLayout):
    pressed = ListProperty([0, 0])

    def on_touch_down(self, touch):
        if self.collide_point(*touch.pos):
            self.pressed = touch.pos
            # # we consumed the touch. return False here to propagate
            # # the touch further to the children.
            return True
        return super(WifiLabel, self).on_touch_down(touch)

class WifiScreen(Screen):
    global alive
    # awai = ObjectProperty()
    switchwifi = ObjectProperty()
    wifilayout = ObjectProperty()
    screenLabel = ObjectProperty()
    #isme wifilayout ka objectproperty bnake use krna h bad  me

    def __init__(self, **kwargs):
        super(WifiScreen, self).__init__(**kwargs)
        self.objectList = [self.screenLabel]

    def offRefresh(self):
        alive = False
##        Clock.unschedule(myAlarmAppObj.refresh)
    # pass

class EthernetScreen(Screen):
    screenLabel = ObjectProperty()

    def __init__(self, **kwargs):
        super(EthernetScreen, self).__init__(**kwargs)
        self.objectList = [self.screenLabel]


class ScreenSaver(Screen):
    radius = NumericProperty(64)

class WifiIcon(ButtonBehavior, Image):
    pass

class ManualButton(ButtonBehavior, Image):
    pass

class ShieldButton(ButtonBehavior, Image):
    pass

class SettingButton(ButtonBehavior, Image):
    pass

class LiveAlarmScreen(Screen):
    alarmTypeText = ObjectProperty()
    cancelAlarmText = ObjectProperty()
    locateIfFireText = ObjectProperty()
    falseAlarmText = ObjectProperty()

    def __init__(self, **kwargs):
        super(LiveAlarmScreen, self).__init__(**kwargs)
        self.objectList = [self.alarmTypeText, self.cancelAlarmText, self.locateIfFireText]


    def CancelAlarm(self):
        print("Worked")
        myAlarmAppObj.cancel_alarm = True
        myAlarmAppObj.root.current = "passwordscreen"

    def FalseAlarm(self):
        print ("FalseAlarm")
        myAlarmAppObj.false_alarm = True
        myAlarmAppObj.root.current = "passwordscreen"

class AssistAlarmScreen(Screen):
    alarmTypeText = ObjectProperty()
    cancelAlarmText = ObjectProperty()

    alarmCancel = BooleanProperty(True)

    def __init__(self, **kwargs):
        super(AssistAlarmScreen, self).__init__(**kwargs)
        self.objectList = [self.alarmTypeText, self.cancelAlarmText]

    def setLabel(self, alaramType, nameOfPerson):
        self.alarmTypeText.text = alaramType + " er utlost hos " + nameOfPerson

    def assistCancelThread(self):
        counter = 0
        while not self.alarmCancel:
            counter += 1
            # print "TIMER COUNTER", counter
            time.sleep(1)
            if counter == 100:
                os.system(
                    'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))

                #################################################################
                ### checkNetworkAlarm Thread START ###
                ######################################
                threading.Thread(target=self.checkNetworkAlarms).start()

                ##################################################################

                myAlarmAppObj.root.current = "menuscreen"

                break

    def assistAlarmActive(self):
        os.system(
            'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(255)" -g' % (globalIpAddress))

        self.alarmCancel = False
        myAlarmAppObj.lastscreen = "assistalarmscreen"
        threading.Thread(target=self.assistCancelThread).start()


    def CancelAlarm(self):
        print("Worked")
        # myAlarmAppObj.cancel_alarm = True
        myAlarmAppObj.root.current = "passwordscreen"
        self.ClearAll()
    # def FalseAlarm(self):
    #     print ("FalseAlarm")
    #     myAlarmAppObj.false_alarm = True
    #     myAlarmAppObj.root.current = "passwordscreen"

    def ClearAll(self):
        myAlarmAppObj.passwordscreen.ClearText()


class IntInput(TextInput):

    input_filter = 'int'
    def insert_text(self, substring, from_undo=False):
        # limit to 4 chars)
        substring = substring[:4 - len(self.text)]
        return super(IntInput, self).insert_text(substring, from_undo=from_undo)

class BurglaryAlarmScreen(Screen):
    burglarytimingslayout = ObjectProperty()
    counter = NumericProperty(0)
    timer = None
    screenLabel = ObjectProperty()
    addButtonText = ObjectProperty()
    fromTextLabel = ObjectProperty()
    toTextLabel = ObjectProperty()
    statusTextLabel = ObjectProperty()

    def __init__(self, **kwargs):
        super(BurglaryAlarmScreen, self).__init__(**kwargs)
        self.objectList = [self.screenLabel, self.addButtonText, self.fromTextLabel,
                           self.toTextLabel, self.statusTextLabel]

    def addtimings(self, timer=None, edit=False):
        global popup
        content = RelativeLayout()
        save = Button(text='Save',pos_hint={'x':.05,'y':.15},size_hint=(.45,.3))
        cancel = Button(text='Cancel', pos_hint={'x':.5,'y':.15},size_hint=(.45,.3))
        fromLabel = Label(text= "From",pos_hint={'x':.1,'y':.7},size_hint=(.35,.25))
        self.fromInputText = IntInput(pos_hint={'x':.1,'y':.5},size_hint=(.35,.25))
        toLabel = Label(text= "To",pos_hint={'x':.55,'y':.7},size_hint=(.35,.25))
        self.toInputText =IntInput(pos_hint={'x':.55,'y':.5},size_hint=(.35,.25))

        content.add_widget(save)
        content.add_widget(cancel)
        content.add_widget(fromLabel)
        content.add_widget(self.fromInputText)
        content.add_widget(toLabel)
        content.add_widget(self.toInputText)

        if edit:
            self.timer = timer
            self.fromInputText.text = timer.fromTimeLabel.text
            self.toInputText.text = timer.toTimeLabel.text


        popup = Popup(title='Add',
                      size_hint=(None, None), size=(300, 200),
                      content=content, disabled=False, auto_dismiss=True)
        cancel.bind(on_release=popup.dismiss)
        save.bind(on_release = self.onSave)

        ########################################################################
        ### LANGUAGE HANDLING ###
        #########################
        conversion = LanguageConversion()
        if myAlarmAppObj.language.lspnr.text == "English":
            languageDict = conversion.englishLanguageDict
        elif myAlarmAppObj.language.lspnr.text == "Norwegian":
            languageDict = conversion.norwainLanguageDict

        objectList = [save, cancel, fromLabel, toLabel, popup]
        conversion.languageConversion(objectList, languageDict)


        #########################################################################

        popup.open()


    def onSave(self,e):
        startAlarmTime = self.fromInputText.text
        endAlarmTime = self.toInputText.text
        try:
            startHr = int(self.fromInputText.text[0:2])
            startMin = int(self.fromInputText.text[2:4])
            endHr = int(self.toInputText.text[0:2])
            endMin = int(self.toInputText.text[2:4])
        except:
            popup.dismiss()
            myAlarmAppObj.errorPopup(errorMessage='Invalid Time ( Use 24hr Format )!!! Enter Again')
            return

        timeError = True
        # print (0 <= startHr < 24), (0 <= endHr < 24), (0 <= startMin < 60), (0 <= endMin < 60)

        if ((0 <= startHr < 24) and (0 <= endHr < 24)) and ((0 <= startMin < 60) and (0 <= endMin < 60)):
            timeError = False

        if len(startAlarmTime) < 4 or len(endAlarmTime) < 4 or timeError:
            popup.dismiss()
            myAlarmAppObj.errorPopup(errorMessage='Invalid Time ( Use 24hr Format )!!! Enter Again')
            return

        self.addBurglaryTimer(self.fromInputText.text,self.toInputText.text)
        popup.dismiss()


    def addBurglaryTimer(self,fromText,toText):
        global burglaryTimerList
        self.counter+=1
        if self.timer:
            self.timer.fromTimeLabel.text, self.timer.toTimeLabel.text = fromText, toText
        else:
            if self.counter<=5:
                btimer = BurglaryTimings(height='50dp',size_hint_y=None)
                btimer.fromTimeLabel.text,btimer.toTimeLabel.text = fromText,toText

                ########################################################################
                ### LANGUAGE HANDLING ###
                #########################
                conversion = LanguageConversion()
                if myAlarmAppObj.language.lspnr.text == "English":
                    languageDict = conversion.englishLanguageDict
                elif myAlarmAppObj.language.lspnr.text == "Norwegian":
                    languageDict = conversion.norwainLanguageDict

                conversion.languageConversion(btimer.objectList, languageDict)

                self.objectList += btimer.objectList
                #########################################################################


                self.burglarytimingslayout.add_widget(btimer)
                burglaryTimerList.append(btimer)
            else:
                None

class BurglaryTimings(BoxLayout):
    fromTimeLabel = ObjectProperty()
    toTimeLabel = ObjectProperty()
    statusTimeLabel = ObjectProperty()
    alarmTimeCheckBox = ObjectProperty()
    editText = ObjectProperty()
    deleteText = ObjectProperty()

    def __init__(self,**kwargs):
        super(BurglaryTimings,self).__init__(**kwargs)
        self.objectList = [self.statusTimeLabel, self.editText, self.deleteText]

    def activeTimer(self):
        if self.alarmTimeCheckBox.active:
            self.statusTimeLabel.text = "Active"
        else:
            self.statusTimeLabel.text = "InActive"

    def removeTimer(self):
        global burglaryTimerList
        myAlarmAppObj.burglaryalarmscreen.burglarytimingslayout.remove_widget(self)
        burglaryTimerList.remove(self)

    def editTimer(self):
        myAlarmAppObj.burglaryalarmscreen.addtimings(timer=self, edit=True)


class MyAlarmApp(App):
    ifvar = NumericProperty(1)
    elvar = NumericProperty(1)
    sstimer = NumericProperty(0)
    index = NumericProperty(-1)
    current_title = StringProperty()
    time = NumericProperty(0)
    screen_names = ListProperty([])
    hierarchy = ListProperty([])
    # clock
    clock = StringProperty('00:00')
    mytime = StringProperty("")
    hour_x = NumericProperty(0)
    hour_y = NumericProperty(0)
    minute_x = NumericProperty(0)
    minute_y = NumericProperty(0)
    second_x = NumericProperty(0)
    second_y = NumericProperty(0)
    digit_x = [None]
    digit_y = [None]
    ManualActive = BooleanProperty(False)

    manualsignal = BooleanProperty(False)
    settingsignal = BooleanProperty(False)
    pwd = StringProperty("")
    enteredpwd = StringProperty("")
    oldtext = StringProperty("")
    newtext = StringProperty("")
    confirmtext = StringProperty("")
    OldTextActive = BooleanProperty(False)
    NewTextActive = BooleanProperty(False)
    ConfirmTextActive = BooleanProperty(False)
    on_off = StringProperty("Off")
    alarmisactive = BooleanProperty(False)
    t = NumericProperty(0)
    cancel_alarm = BooleanProperty(False)
    false_alarm = BooleanProperty(False)

    burglarycancelButton=BooleanProperty(False)
    burglarycancelButton1 = BooleanProperty(False)

    firecancelButton = BooleanProperty(False)
    firecancelButton1 = BooleanProperty(False)

    floodcancelButton = BooleanProperty(False)
    floodcancelButton1 = BooleanProperty(False)

    smokecancelButton = BooleanProperty(False)
    smokecancelButton1 = BooleanProperty(False)

    alarm_type_text = StringProperty("")
    DeactivateFireSiren = BooleanProperty()
    DeactivateBurglarySiren = ()
    lastscreen = StringProperty("menuscreen")


    burglaryOn = False
    burglaryOff = True
    burglaryFound = False
    burglaryTimer = 0

    flameOn = False
    flameOff = True
    fireFound = False
    fireTimer = 0

    floodOn = False
    floodOff = True
    floodFound = False
    floodTimer = 0

    smokeOn = False
    smokeOff = True
    smokeFound = False
    smokeTimer = 0


    def __init__(self, **kwargs):
        global serverOK
        super(MyAlarmApp, self).__init__(**kwargs)


    def checkServerConnection(self):
        db = MySQLdb.connect("127.0.0.1", "root", "1234", "appdb")
        cursor = db.cursor()
        cursor.execute("SELECT connected from serverTable")
        data = cursor.fetchone()[0]
        # print "SERVER STATUS", data
        db.close()
        if data == 1:
            return True

        return False

    def on_stop(self):
        Clock.unschedule(self.start_timer)
        Clock.unschedule(self.update_clock)

        global stop
        stop.set()

    def resetTimer(self):
        self.sstimer = 0

    def settingUpDatabase(self):
        db = MySQLdb.connect("127.0.0.1", "root", "1234")
        cursor = db.cursor()
        try:
            cursor.execute('create database appdb')
        except:
            None
        cursor.execute('use appdb')

        try:
            cursor.execute("CREATE TABLE webtable(webpwd VARCHAR(10) NOT NULL)")
            cursor.execute("INSERT INTO webtable VALUES(1234)")
        except:
            None

        try:
            cursor.execute("CREATE TABLE serverTable(connected INT(1) NOT NULL, "
                           "serverAddress VARCHAR(30) NULL, password VARCHAR(30) NULL)")
            cursor.execute("INSERT INTO serverTable(connected) VALUES(0)")
        except:
            None

        try:
            cursor.execute("CREATE TABLE versionTable(version VARCHAR(30) NOT NULL)")
            cursor.execute("INSERT INTO versionTable(version) VALUES('ac0.v1')")
        except:
            None
        db.commit()
        db.close()

    def build(self):
        global serverOK, globalIpAddress

        self.settingUpDatabase()


        self.get_details()
        self.get_password_from_db()
        serverOK = self.checkServerConnection()

        # calculate digit positions for analog clock
        for i in range(1, 13):
            self.digit_x.append(cos((3 - i) * 30 * pi / 180.0))
            self.digit_y.append(sin((3 - i) * 30 * pi / 180.0))

        Clock.schedule_interval(self.start_timer, 1)
        Clock.schedule_interval(self.update_clock,1)
        # Clock.schedule_interval(self.activateAlarm,1)
        # self.activateAlarm()

        #################################################################
        ### checkNetworkAlarm Thread START ###
        ######################################
        threading.Thread(target=self.checkNetworkAlarms).start()

        ##################################################################

        ####ScreenManager###########
        sm = Screen_Manager()
        self.passwordscreen = PasswordScreen(name='passwordscreen')
        self.menuscreen = MenuScreen(name='menuscreen')
        self.settingscreen = SettingScreen(name='settingscreen')
        self.alarmscreen = AlarmScreen(name='alarmscreen')
        self.securityscreen = SecurityScreen(name='securityscreen')
        self.changepinscreen = ChangePinScreen(name='changepinscreen')
        self.changewebpinscreen = ChangeWebPinScreen(name='changewebpinscreen')
        self.clockscreen = ClockScreen(name="clockscreen")
        self.ethernetwifi = EthernetWifi(name="ethernetwifi")
        self.wifiscreen = WifiScreen(name="wifiscreen")
        self.ethernetscreen = EthernetScreen(name="ethernetscreen")
        self.language = LanguageScreen(name="language")
        self.screensaver = ScreenSaver(name="screensaver")
        self.serversettings = ServerSettings(name="serversettings")
        self.firmwarescreen = FirmwareScreen(name="firmwarescreen")
        self.livealarmscreen = LiveAlarmScreen(name='livealarmscreen')
        self.assistalarmscreen = AssistAlarmScreen(name='assistalarmscreen')
        self.burglaryalarmscreen = BurglaryAlarmScreen(name="burglaryalarmscreen")

        screens = [self.passwordscreen, self.menuscreen, self.settingscreen, self.alarmscreen,
                   self.securityscreen, self.changepinscreen, self.changewebpinscreen, self.clockscreen, self.ethernetscreen,
                   self.ethernetwifi, self.wifiscreen, self.language, self.screensaver,
                   self.serversettings, self.firmwarescreen,self.livealarmscreen, self.assistalarmscreen,
                   self.burglaryalarmscreen]

        if globalIpAddress != "None":
            print "globalIpAddress:", globalIpAddress
            self.menuscreen.wifiImage.source = "images/wifiOn.jpg"
            self.wifiscreen.switchwifi.active = True

        for screen in screens:
            sm.add_widget(screen)

        return sm

    def fetchDevices(self):
        print "FETCHING DEVICES"
        self.sirenId, self.flameId, self.burglaryId, self.floodId, self.smokeId = fetchingDevices(globalIpAddress)

    def get_details(self):
        global globalIpAddress
        self.macAddress = commands.getoutput("cat /sys/class/net/eth0/address")
        self.ethstatus = commands.getoutput("cat /sys/class/net/eth0/carrier")
        self.wifimacaddress = commands.getoutput("cat /sys/class/net/wlan0/address")
        # print self.ethstatus,self.macAddress,self.wifimacaddress

        try:
            self.ipAddress = commands.getoutput("ifconfig").split("wlan0")[1].split("\n")[1].split()[1][5:]
        except:
            self.ipAddress = "None"

        # self.ethIpAddress = commands.getoutput("ifconfig").split("eth0")[1].split("\n")[1].split()[1][5:]

        self.ethIpAddress = "CAST"
        ##########################################################
        ### CHECKING IF NOT CONNECTED ###
        #################################
        if self.ipAddress == "CAST":
            self.ipAddress = "None"
        if self.ethIpAddress == "CAST":
            self.ethIpAddress = "None"

        if self.ethIpAddress != "None":
            globalIpAddress = self.ethIpAddress
        elif self.ipAddress != "None":
            globalIpAddress = self.ipAddress

        ##########################################################

        globalIpAddress = "192.168.1.5"#self.ipAddress

        ##############################################################
        ### FETCHING IDS OF SENSORS ###
        ###############################
        # self.fetchDevices()
        threading.Thread(target=self.fetchDevices).start()
        ###############################################################


        print self.ipAddress, self.ethIpAddress

    def checkalarm(self,d):
        if self.alarmisactive:
            print("type of alarm")
            Clock.unschedule(self.checkalarm)
            self.alarmtimer()

    def alarmtimer(self):
        Clock.schedule_interval(self.timer,1)

    def timezonefunc(self,zone):
        commands.getoutput("sudo timedatectl set-timezone %s" % (zone))
        # self.tzone = datetime.now(timezone('UTC')).astimezone(timezone(zone))
        # self.tzone = self.tzone.strftime(self.tzone)

    def refresh(self):
        #jawla bhai ya pe tujhe aise wifi search krna h jaise ubuntu krta h
        cell = Cell.all('wlan0')
        self.wifilayout.clear_widgets()
        # print cell
        # print "sud"

        for c in cell:
            # wifinamelist.append(c.ssid)
            # print c.ssid,c
            self.networkButton = ssidButton(text=c.ssid, cellname = c, height=50, bold =True,size_hint_y=None,background_color=(0.7,0.7,1,1))#,on_release=self.ssidclicked))
            self.wifilayout.add_widget(self.networkButton)

    def wifi_on(self):
        global alive
        switch = self.wifiscreen.switchwifi
        self.wifilayout = self.wifiscreen.wifilayout
        # wifi_label = self.root.ids.wifi_label


        wifinamelist = []
        if switch.active:
##            self.refresh()
            alive = True
            def A():
                global alive
                while alive:
                    self.refresh()
                    time.sleep(5)

            if alive:
                thread = threading.Thread(target= A)
                thread.daemon = True
                thread.start()

            # self.refresh(None)
            # Clock.schedule_interval(self.refresh, 5)
            # self.on_off = "On"
            # cell = Cell.all('wlan0')
            #
            #
            # for c in cell:
            #     # wifinamelist.append(c.ssid)
            #     self.wifilayout.add_widget(ssidButton(text=c.ssid, cellname = c,height=50,size_hint_y=None,background_color=(0.9411,0.9725,1,1)))#,on_release=self.ssidclicked))
        else:
            # Clock.unschedule(self.refresh)
            alive = False
            # self.on_off = "Off"
            self.wifilayout.clear_widgets()
            # wifi_label.text = on_off

    def exit(self):
        global stopper, activateThread, stop, alive, checkNetworkFlag
        stopper=True
        alive = False
        checkNetworkFlag = False
        myAlarmAppObj.DeactivateFireSiren = True
        myAlarmAppObj.DeactivateBurglarySiren = True
        myAlarmAppObj.DeactivateFloodSiren = True
        myAlarmAppObj.DeactivateSmokeSiren = True
        # cleanup_stop_thread()
        # activateThread.__stop()

        # stop.set()
        exit()

    def burglaryTimerChecker(self):
        global burglaryTimerList
        currentTime = datetime.now().strftime("%H%M%S")
        for timer in burglaryTimerList:
            startTime = timer.fromTimeLabel.text + "00"
            endTime = timer.toTimeLabel.text + "00"
            # print currentTime, startTime, currentTime == startTime
            if currentTime == startTime and timer.statusTimeLabel.text == "Active":
                myAlarmAppObj.alarmscreen.burglaryCheckBox.active = True
            elif currentTime == endTime and timer.statusTimeLabel.text == "Active":
                myAlarmAppObj.alarmscreen.burglaryCheckBox.active = False


    def checkNetworkAlarms(self):
        global globalUser, checkNetworkFlag
        # time.sleep(5)
        while checkNetworkFlag:
            alarmInfo = fetchAlarm(globalUser)
            # print "alarmInfo:", alarmInfo
            try:
                dictAlarmInfo = json.loads(alarmInfo)[0]
                # print "dictAlarmInfo", json.loads(alarmInfo)
                self.fetchUserId = dictAlarmInfo['user_id']
                self.fetchUserName = dictAlarmInfo['user_name']
                if self.fetchUserId == globalUser:
                    continue
                self.fetchAlarmId = dictAlarmInfo['alarm_id']
                self.fetchAlarmType = dictAlarmInfo['type']
                self.fetchTime = dictAlarmInfo['time']
                self.fetchPhoneNumber = dictAlarmInfo['phone_number']
                self.fetchAddress = dictAlarmInfo['address']

                self.assistalarmscreen.setLabel(self.fetchAlarmType, self.fetchUserName)

                self.assistalarmscreen.assistAlarmActive()
                print ("UserID: %s, UserName: %s, AlarmID: %s, \nAlarmType: %s, AlarmTime: %s, \nPhoneNumber: %s, Address: %s") % \
                      (self.fetchUserId, self.fetchUserName, self.fetchAlarmId, self.fetchAlarmType, self.fetchTime, self.fetchPhoneNumber, self.fetchAddress)

                myAlarmAppObj.root.current = "assistalarmscreen"
                break
            except:
                continue





    def update_clock(self,dt):
        # " "+time.strftime("%H:%M:%S")+"\n"+time.strftime("%d.%m.%Y")

        # def update_all_steady(dt):
            global stop
            self.mytime = time.asctime()
            # clock
            clock = datetime.now().strftime("%H:%M:%S")+"\n"+datetime.now().strftime("%d.%m.%Y")
            now = datetime.now()
            if clock != self.clock:
                self.clock = " " +now.strftime("%H:%M:%S")+"\n"+now.strftime("%d.%m.%Y")
            self.hour_x = cos((30 * (3 - ((now.hour + now.minute / 60.0) % 12)) + 360) * pi / 180.0)
            self.hour_y = sin((30 * (3 - ((now.hour + now.minute / 60.0) % 12)) + 360) * pi / 180.0)
            self.minute_x = cos((6 * (15 - now.minute - now.second / 60.0) + 360) * pi / 180.0)
            self.minute_y = sin((6 * (15 - now.minute - now.second / 60.0) + 360) * pi / 180.0)
            self.second_x = cos((6 * (15 - now.second) + 360) * pi / 180.0)
            self.second_y = sin((6 * (15 - now.second) + 360) * pi / 180.0)

            # print self.clock
            self.burglaryTimerChecker()

            # self.checkNetworkAlarms()

        # while True:
        #     if stop.is_set():
        #         return
        #     time.sleep(1)
        #     update_all_steady()
        #     Clock.schedule_once(update_all_steady, 1)
        #
        # Clock.schedule_once(update_all_steady)

    def validate_password(self):
        global popup

        def activatingAlarmThread(label):
            if serverOK:
                self.alarmID = activateAlarm(globalUser, datetime.now().strftime("%d-%m-%Y %H:%M:%S"), label)

        if self.passwordscreen.entrypwd.text == self.pwd:
            if self.lastscreen == "menuscreen":
                if self.manualsignal:
                    self.manualsignal = False
                    self.ManualActive = not self.ManualActive
                    if self.ManualActive:
                        self.menuscreen.manual.source = "images/handg4.png"
                        threading.Thread(target=activatingAlarmThread, args=['Manual Alarm']).start()

                    else:
                        self.menuscreen.manual.source = "images/handr4.png"
                    self.root.current = "menuscreen"



                elif self.settingsignal:
                    self.root.current = "settingscreen"
                    self.settingsignal = False

                elif self.menuscreen.activeShieldSignal:
                    self.menuscreen.activeShieldSignal = False
                    self.menuscreen.ActivatingShield()
                    self.root.current = "menuscreen"

                else:
                    self.root.current = "menuscreen"



            elif self.lastscreen == "livealarmscreen" and (self.cancel_alarm or self.false_alarm):
                self.cancel_alarm = False
                self.false_alarm = False
                print "STOP STOP"
                self.burglarycancelButton = True
                self.firecancelButton = True
                self.floodcancelButton = True
                self.smokecancelButton = True

                self.root.current = "menuscreen"

            elif self.lastscreen == "assistalarmscreen":
                self.assistalarmscreen.alarmCancel = True
                print "CANCELLING"
                os.system(
                    'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))

                self.root.current = "menuscreen"
                #################################################################
                ### checkNetworkAlarm Thread START ###
                ######################################
                threading.Thread(target=self.checkNetworkAlarms).start()

                ##################################################################

            elif self.lastscreen == "screensaver":
                self.root.current = "menuscreen"

                # else:
            #     self.root.current = "menuscreen"
        else:
            content = BoxLayout(orientation='vertical',on_touch_down = self.dismiss_popup)
            content_cancel = Button(text='OK', size_hint_y=None, height=40)
            content_label = Label(text='Wrong Password !!! Try Again')
            content.add_widget(content_label)
            content.add_widget(content_cancel)
            popup = Popup(title='Error',
                          size_hint=(None, None), size=(300, 200),
                          content=content, disabled=False, auto_dismiss=True)
            content_cancel.bind(on_release=popup.dismiss)

            ########################################################################
            ### LANGUAGE HANDLING ###
            #########################
            conversion = LanguageConversion()
            if myAlarmAppObj.language.lspnr.text == "English":
                languageDict = conversion.englishLanguageDict
            elif myAlarmAppObj.language.lspnr.text == "Norwegian":
                languageDict = conversion.norwainLanguageDict

            objectList = [content_label, content_cancel, popup]
            conversion.languageConversion(objectList, languageDict)

            #########################################################################

            popup.open()
        self.passwordscreen.ClearText() ##### still left ###

    def dismiss_popup(self,x,y):
        print("touch Position",x,y)
        self.resetTimer()

    def ActiveManual(self):
        self.manualsignal = True
        self.lastscreen = "menuscreen"
        self.root.current = "passwordscreen"

    def Settings(self):
        self.settingsignal = True
        self.lastscreen = "menuscreen"
        self.root.current = "passwordscreen"

    def get_password_from_db(self):
        db = MySQLdb.connect("127.0.0.1", "root", "1234", "appdb")
        cursor = db.cursor()
        cursor.execute("SELECT webpwd from webtable")
        data = cursor.fetchone()
        self.pwd = "%s" % data
        print self.pwd
        db.close()

    def entry_pwd_digit(self, num):
        self.enteredpwd = self.enteredpwd + num
        self.passwordscreen.entrypwd.text = self.enteredpwd

    def ClickedNumber(self, num):
        if self.OldTextActive:
            self.oldtext = self.oldtext + num
            self.changepinscreen.oldtext.text = self.oldtext
        elif self.NewTextActive:
            self.newtext = self.newtext + num
            self.changepinscreen.newtext.text = self.newtext
        elif self.ConfirmTextActive:
            self.confirmtext = self.confirmtext + num
            self.changepinscreen.confirmtext.text = self.confirmtext
        else:
            None

    def ActiveOldText(self):
        self.OldTextActive = True
        self.NewTextActive = False
        self.ConfirmTextActive = False

    def ActiveNewText(self):
        self.OldTextActive = False
        self.NewTextActive = True
        self.ConfirmTextActive = False

    def ActiveConfirmText(self):
        self.OldTextActive = False
        self.NewTextActive = False
        self.ConfirmTextActive = True

    def ChangePassword(self):
        global popup

        if self.pwd == self.oldtext:
            self.npwd = self.newtext
            self.npwd1 = self.confirmtext
            if self.npwd == self.npwd1:

                if self.npwd == self.pwd:
                    content = BoxLayout(orientation='vertical',on_touch_down = self.dismiss_popup)
                    content_cancel = Button(text='OK', size_hint_y=None, height=40)
                    content_label = Label(text="Password must differ from Old Password !!!")
                    content.add_widget(content_label)
                    content.add_widget(content_cancel)

                    popup = Popup(title='Error',
                                  size_hint=(None, None), size=(400, 200),
                                  content=content, disabled=False, auto_dismiss=True)
                    content_cancel.bind(on_release=popup.dismiss)

                    ########################################################################
                    ### LANGUAGE HANDLING ###
                    #########################
                    conversion = LanguageConversion()
                    if myAlarmAppObj.language.lspnr.text == "English":
                        languageDict = conversion.englishLanguageDict
                    elif myAlarmAppObj.language.lspnr.text == "Norwegian":
                        languageDict = conversion.norwainLanguageDict

                    objectList = [content_label, content_cancel, popup]
                    conversion.languageConversion(objectList, languageDict)

                    #########################################################################

                    popup.open()
                    self.ClearAll()
                    return

                elif len(self.npwd) < 4:
                    content = BoxLayout(orientation='vertical',on_touch_down = self.dismiss_popup)
                    content_cancel = Button(text='OK', size_hint_y=None, height=40)
                    content_label = Label(text='Password must be at least four characters long !!!')
                    content.add_widget(content_label)
                    content.add_widget(content_cancel)
                    popup = Popup(title='Error',
                                  size_hint=(None, None), size=(400, 200),
                                  content=content, disabled=False, auto_dismiss=True)
                    content_cancel.bind(on_release=popup.dismiss)

                    ########################################################################
                    ### LANGUAGE HANDLING ###
                    #########################
                    conversion = LanguageConversion()
                    if myAlarmAppObj.language.lspnr.text == "English":
                        languageDict = conversion.englishLanguageDict
                    elif myAlarmAppObj.language.lspnr.text == "Norwegian":
                        languageDict = conversion.norwainLanguageDict

                    objectList = [content_label, content_cancel, popup]
                    conversion.languageConversion(objectList, languageDict)

                    #########################################################################

                    popup.open()
                    self.ClearAll()

                    return

                else:
                    None

                self.update_Details(self.npwd)
                self.get_password_from_db()
                self.root.current = "securityscreen"
                self.ClearAll()

            else:
                content = BoxLayout(orientation='vertical',on_touch_down = self.dismiss_popup)
                content_cancel = Button(text='OK', size_hint_y=None, height=40)
                content_label = Label(text="Password didn't match!!! Try Again")
                content.add_widget(content_label)
                content.add_widget(content_cancel)
                popup = Popup(title='Error',
                              size_hint=(None, None), size=(400, 200),
                              content=content, disabled=False, auto_dismiss=True)
                content_cancel.bind(on_release=popup.dismiss)

                ########################################################################
                ### LANGUAGE HANDLING ###
                #########################
                conversion = LanguageConversion()
                if myAlarmAppObj.language.lspnr.text == "English":
                    languageDict = conversion.englishLanguageDict
                elif myAlarmAppObj.language.lspnr.text == "Norwegian":
                    languageDict = conversion.norwainLanguageDict

                objectList = [content_label, content_cancel, popup]
                conversion.languageConversion(objectList, languageDict)

                #########################################################################

                popup.open()
                self.ClearAll()

        else:
            content = BoxLayout(orientation='vertical',on_touch_down = self.dismiss_popup)
            content_cancel = Button(text='OK', size_hint_y=None, height=40)
            content_label = Label(text='Wrong Password..!!! Try Again')
            content.add_widget(content_label)
            content.add_widget(content_cancel)
            popup = Popup(title='Error',
                          size_hint=(None, None), size=(300, 200),
                          content=content, disabled=False, auto_dismiss=True)
            content_cancel.bind(on_release=popup.dismiss)
            ########################################################################
            ### LANGUAGE HANDLING ###
            #########################
            conversion = LanguageConversion()
            if myAlarmAppObj.language.lspnr.text == "English":
                languageDict = conversion.englishLanguageDict
            elif myAlarmAppObj.language.lspnr.text == "Norwegian":
                languageDict = conversion.norwainLanguageDict

            objectList = [content_label, content_cancel, popup]
            conversion.languageConversion(objectList, languageDict)

            #########################################################################


            popup.open()
            self.ClearAll()

    def update_Details(self, npwd):
        try:
            query = """update webtable set webpwd = %s """
            data = (npwd)
            db = MySQLdb.connect("127.0.0.1", "root", "1234", "appdb")
            cursor = db.cursor()
            cursor.execute('update webtable set webpwd = %s', [npwd])
            db.commit()
        except MySQLdb.Error as err:
            content = BoxLayout(orientation='vertical',on_touch_down = self.dismiss_popup)
            content_cancel = Button(text='OK', size_hint_y=None, height=40)
            content_label = Label(text='Some Error Occured!!!')
            content.add_widget(content_label)
            content.add_widget(content_cancel)
            popup = Popup(title='Error',
                          size_hint=(None, None), size=(300, 200),
                          content=content, disabled=False, auto_dismiss=True)
            content_cancel.bind(on_release=popup.dismiss)

            ########################################################################
            ### LANGUAGE HANDLING ###
            #########################
            conversion = LanguageConversion()
            if myAlarmAppObj.language.lspnr.text == "English":
                languageDict = conversion.englishLanguageDict
            elif myAlarmAppObj.language.lspnr.text == "Norwegian":
                languageDict = conversion.norwainLanguageDict

            objectList = [content_label, content_cancel, popup]
            conversion.languageConversion(objectList, languageDict)

            #########################################################################

            popup.open()
            self.ClearAll()

        finally:
            db.close()
            cursor.close()

    def ClearAll(self):
        self.passwordscreen.entrypwd.text = \
            self.changepinscreen.confirmtext.text = \
            self.changepinscreen.oldtext.text = \
            self.changepinscreen.newtext.text = \
            self.oldtext = self.newtext = self.confirmtext = ""

    def Clear(self):
        if self.OldTextActive:
            self.oldtext = self.changepinscreen.oldtext.text = ""
        elif self.NewTextActive:
            self.newtext = self.changepinscreen.newtext.text = ""
        elif self.ConfirmTextActive:
            self.confirmtext = self.changepinscreen.confirmtext.text = ""
        else:
            None

    def start_timer(self,dt):
        global popup

        ## screensaver timer wont stop even
        ##  on when cureent screen is screensaver

        self.sstimer += 1

        if self.sstimer == 180:
            try:
                popup.dismiss()
            except:
                None
            if self.root.current != "livealarmscreen" and self.root.current != "assistalarmscreen":
                self.root.current = "screensaver"
                self.lastscreen = "screensaver"
                self.passwordscreen.ClearText()
                self.sstimer = 0


    def activatingAlarmThread(self, label):
        if serverOK:
            self.alarmID = activateAlarm(globalUser, datetime.now().strftime("%d-%m-%Y %H:%M:%S"), label)

    def deactivatingAlarmThread(self):
        if serverOK:
            deactivateAlarm(self.alarmID)


    def sirenActivate(self):
        os.system(
            'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[%s].instances[0].SwitchBinary.Set(255)" -g' % (
            globalIpAddress, self.sirenId))

    def sirenDeactivate(self):
        os.system(
            'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[%s].instances[0].SwitchBinary.Set(0)" -g' % (
            globalIpAddress, self.sirenId))


    def startBuzzer(self):
        global buzzerActive
        while buzzerActive:
            self.stream.write(self.WAVEDATA)
            time.sleep(1)
            print "Running"

        self.stream.stop_stream()
        self.stream.close()
        self.pyAudio.terminate()


    def ActivateFireSiren(self):

        def A():
            self.DeactivateFireSiren= False
            while not self.DeactivateFireSiren:
                # print "in while"
                self.ActivateFireSirenThread()


        threading.Thread(target=A).start()

        # global ifvar,elvar

        # print ifvar,elvar
        ##os.system('curl --user admin:arne123 --data " " "http://192.168.0.107:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))
        # self.ifvar = 0
        # self.elvar = 0
    def ActivateFireSirenThread(self):
        import os
        global serverOK, buzzerActive

        # self.result1 = os.popen(
        #     'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[4].instances[0].SensorBinary.data[1].level.value" -g' % (globalIpAddress)).read()

        self.fireresult= os.popen(
            'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[%s].instances[0].SensorBinary.data[1].level.value" -g' % (globalIpAddress, self.flameId)).read()

        # self.fireresult = "true"
        print "self.fireresult: ", self.fireresult

        if self.fireresult == "true" and not self.flameOn and not self.firecancelButton and not self.burglaryFound and not self.floodFound and not self.smokeFound:
            print "hey"
            ##        time.sleep(1)
            # self.ifvar = 0
            # self.elvar = 1
            self.flameOn = True
            self.flameOff = True
            # self.el = 0
            # os.system(
            #     'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(255)" -g' % (globalIpAddress))

            ######################################################################
            ### ACTIVATE THE BUZZER HERE ###
            ################################
            self.stream, self.WAVEDATA, self.pyAudio = buzzer()
            buzzerActive = True
            threading.Thread(target=self.startBuzzer).start()

            ########################################################################

            # if serverOK:
            #     self.alarmID = activateAlarm(globalUser, datetime.now().strftime("%d-%m-%Y %H:%M:%S"), 'Flame')
            threading.Thread(target=self.activatingAlarmThread, args=['Flame']).start()

            myAlarmAppObj.alarm_type_text = "Flame"
            self.fireFound = True
            print self.fireresult
            self.lastscreen = "livealarmscreen"
            self.root.current = "livealarmscreen"

        elif  self.fireresult == "false" and self.flameOff and self.firecancelButton1:
            self.flameOn = False
            # if self.cancelButton != 'Hey1':
            #     os.system
            #         'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))

            self.firecancelButton = False
            self.firecancelButton1=False
            print self.fireresult
        elif self.firecancelButton:
            self.firecancelButton=""
            self.firecancelButton1 = True

            # os.system(
            #     'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))
            if self.fireTimer > 30:
                self.sirenDeactivate()
            # if serverOK:
            #     deactivateAlarm(self.alarmID)
            buzzerActive = False
            threading.Thread(target=self.deactivatingAlarmThread).start()

            self.fireFound = False
            self.fireTimer = 0

        if self.fireTimer == 30:
            print "PLAY SIREN"
            # os.system(
            #     'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[%s].instances[0].SwitchBinary.Set(255)" -g' % (globalIpAddress, self.sirenId))
            buzzerActive = False
            self.sirenActivate()

    def ActivateBurglarySiren(self):

        def A():
            self.DeactivateBurglarySiren = False
            while not self.DeactivateBurglarySiren:
                # print "in while", self.burglaryFound
                self.ActivateBurglarySirenThread()
                if self.burglaryFound:
                    self.burglaryTimer += 1
                    # print "self.burglaryTimer: ", self.burglaryTimer
                    time.sleep(0.95)

        threading.Thread(target=A).start()
    def ActivateBurglarySirenThread(self):

        global serverOK, buzzerActive
        self.burglaryresult = os.popen(
            'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[%s].instances[0].SensorBinary.data[1].level.value" -g' % (globalIpAddress, self.burglaryId)).read()


        # self.burglaryresult = "true"
        # print "self.burglaryresult: ", self.burglaryresult

        if self.burglaryresult == "true" and not self.burglaryOn and not self.burglarycancelButton and not self.fireFound and not self.floodFound and not self.smokeFound:
            print "hey"
            ##        time.sleep(1)
            self.burglaryOn = True
            self.burglaryOff = True
            # self.elvar = 1
            # self.el = 0
            self.burglaryFound = True
            # os.system(
            #     'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(255)" -g' % (globalIpAddress))

            ######################################################################
            ### ACTIVATE THE BUZZER HERE ###
            ################################
            self.stream, self.WAVEDATA, self.pyAudio = buzzer()
            buzzerActive = True
            threading.Thread(target=self.startBuzzer).start()

            ########################################################################

            ####################################################################
            ### WILL BE DONE AFTER 60 SECONDS ###
            #####################################
            # if serverOK:
            #     self.alarmID = activateAlarm(globalUser, datetime.now().strftime("%d-%m-%Y %H:%M:%S"), "Burglary")
            threading.Thread(target=self.activatingAlarmThread, args=['Burglary']).start()

            #####################################################################

            myAlarmAppObj.alarm_type_text = "Burglary"

            print self.burglaryresult
            self.lastscreen = "livealarmscreen"
            self.root.current = "livealarmscreen"

        elif (self.burglaryresult == "false" and self.burglaryOff) and self.burglarycancelButton1:
            self.burglaryOn = False
            # if self.cancelButton != 'Hey1':
            #     os.system
            #         'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))

            # os.system(
            #     'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))

            self.burglarycancelButton = False
            self.burglarycancelButton1 = False

            print self.burglaryresult
        elif self.burglarycancelButton:
            self.burglarycancelButton = ""
            self.burglarycancelButton1 = True


            if self.burglaryTimer > 30:
                # os.system(
                #     'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[%s].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress, self.sirenId))
                self.sirenDeactivate()

            buzzerActive = False
            # if serverOK:
            #     deactivateAlarm(self.alarmID)
            threading.Thread(target=self.deactivatingAlarmThread).start()

            self.burglaryFound = False
            self.burglaryTimer = 0

        if self.burglaryTimer == 30:
            print "PLAY SIREN"
            # os.system(
            #     'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[%s].instances[0].SwitchBinary.Set(255)" -g' % (globalIpAddress, self.sirenId))
            buzzerActive = False
            self.sirenActivate()

            # def ActivateBurglarySirenThread2(self):
    #     import os
    #
    #     self.burglaryresult = os.popen(
    #         'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[7].instances[0].SensorBinary.data[1].level.value" -g' % (globalIpAddress)).read()
    #
    #     print "self.burglaryresult: ", self.burglaryresult, self.ifvar, not self.burglarycancelButton
    #
    #     if self.burglaryresult == "true" and self.ifvar == 1 and not self.burglarycancelButton:# and not self.fireFound:
    #         print "hey"
    #         ##        time.sleep(1)
    #         self.ifvar = 0
    #         self.elvar = 1
    #         os.system(
    #             'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(255)" -g' % (globalIpAddress))
    #
    #         myAlarmAppObj.alarm_type_text = "Burglary"
    #         self.burglaryFound = True
    #         # print self.burglaryresult
    #         self.lastscreen = "livealarmscreen"
    #         self.root.current = "livealarmscreen"
    #
    #     elif self.burglaryresult == "false" and self.elvar == 1 and self.burglarycancelButton1:
    #         self.ifvar = 1
    #         # if self.cancelButton != 'Hey1':
    #         #     os.system
    #         #         'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))
    #
    #         self.burglarycancelButton = False
    #         self.burglarycancelButton1 = False
    #         print self.burglaryresult
    #     elif self.burglarycancelButton:
    #         self.burglarycancelButton = ""
    #         self.burglarycancelButton1 = True
    #         print "sudhanshu"
    #         os.system(
    #             'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))
    #         self.burglaryFound = False

    def ActivateFloodSiren(self):

        def A():
            self.DeactivateFloodSiren = False
            while not self.DeactivateFloodSiren:
                # print "in while"
                self.ActivateFloodSirenThread()
                if self.floodFound:
                    self.floodTimer += 1
                    print "self.floodTimer: ", self.floodTimer
                    time.sleep(0.95)

        threading.Thread(target=A).start()

        # global ifvar,elvar

        # print ifvar,elvar
        ##os.system('curl --user admin:arne123 --data " " "http://192.168.0.107:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))
        # self.ifvar = 0
        # self.elvar = 0
    def ActivateFloodSirenThread(self):
        import os

        global serverOK, buzzerActive

        # self.result1 = os.popen(
        #     'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[4].instances[0].SensorBinary.data[1].level.value" -g' % (globalIpAddress)).read()

        self.floodresult = os.popen(
            'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[%s].instances[0].AlarmSensor.data[5].sensorState.value" -g' % (globalIpAddress, self.floodId)).read()

        if self.floodresult == '255':
            self.floodresult = "true"
        elif self.floodresult == '0':
            self.floodresult = "false"

        print "self.floodresult: ", self.floodresult

        if self.floodresult == "true" and not self.floodOn and not self.floodcancelButton and not self.burglaryFound and not self.fireFound and not self.smokeFound:
            print "hey"
            ##        time.sleep(1)
            # self.ifvar = 0
            # self.elvar = 1
            self.floodOn = True
            self.floodOff = True
            # self.el = 0
            # os.system(
            #     'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(255)" -g' % (globalIpAddress))


            ######################################################################
            ### ACTIVATE THE BUZZER HERE ###
            ################################
            self.stream, self.WAVEDATA, self.pyAudio = buzzer()
            buzzerActive = True
            threading.Thread(target=self.startBuzzer).start()

            ########################################################################

            ###########################################################################
            ### FLOOD SIREN WILL NOT BE DISTRIBUTED ON NETWORK ###
            ######################################################
            # ##############################################################
            # ### WILL BE DONE AFTER 60 SECONDS ###
            # #####################################
            # self.alarmID = activateAlarm(globalUser, datetime.now().strftime("%d-%m-%Y %H:%M:%S"), 'Flood')
            # ###############################################################

            ###########################################################################
            myAlarmAppObj.alarm_type_text = "Flood"
            self.floodFound = True
            print self.floodresult
            self.lastscreen = "livealarmscreen"
            self.root.current = "livealarmscreen"

        elif self.floodresult == "false" and self.floodOff and self.floodcancelButton1:
            self.floodOn = False
            # if self.cancelButton != 'Hey1':
            #     os.system
            #         'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))

            self.floodcancelButton = False
            self.floodcancelButton1 = False
            print self.floodresult
        elif self.floodcancelButton:
            self.floodcancelButton = ""
            self.floodcancelButton1 = True

            # os.system(
            #     'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))
            # deactivateAlarm(self.alarmID)
            if self.floodTimer > 30:
                self.sirenDeactivate()

            buzzerActive = False

            self.floodFound = False
            self.floodTimer = 0

        if self.floodTimer == 30:
            print "PLAY SIREN"
            # os.system(
            #     'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(255)" -g' % (globalIpAddress))
            buzzerActive = False
            self.sirenActivate()

    def ActivateSmokeSiren(self):

        def A():
            self.DeactivateSmokeSiren = False
            while not self.DeactivateSmokeSiren:
                # print "in while"
                self.ActivateSmokeSirenThread()
                if self.smokeFound:
                    self.smokeTimer += 1
                    # print "self.smokeTimer: ", self.smokeTimer
                    time.sleep(0.95)

        threading.Thread(target=A).start()

        # global ifvar,elvar

        # print ifvar,elvar
        ##os.system('curl --user admin:arne123 --data " " "http://192.168.0.107:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))
        # self.ifvar = 0
        # self.elvar = 0
    def ActivateSmokeSirenThread(self):
        import os
        global serverOK, buzzerActive
        self.smokeresult = os.popen(
            'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[%s].instances[0].AlarmSensor.data[1].sensorState.value" -g' % (globalIpAddress, self.smokeId)).read()

        if self.smokeresult == "255":
            self.smokeresult = "true"
        elif self.smokeresult == "0":
            self.smokeresult = "false"

        print "self.smokeresult: ", self.smokeresult

        if self.smokeresult == "true" and not self.smokeOn and not self.smokecancelButton and not self.burglaryFound and not self.fireFound and not self.floodFound:
            print "hey"
            ##        time.sleep(1)
            # self.ifvar = 0
            # self.elvar = 1
            self.smokeOn = True
            self.smokeOff = True
            # self.el = 0
            os.system(
                'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(255)" -g' % (globalIpAddress))

            ######################################################################
            ### ACTIVATE THE BUZZER HERE ###
            ################################
            self.stream, self.WAVEDATA, self.pyAudio = buzzer()
            buzzerActive = True
            threading.Thread(target=self.startBuzzer).start()

            ########################################################################

            ##############################################################
            ### WILL BE DONE AFTER 60 SECONDS ###
            #####################################
            # if serverOK:
            #     self.alarmID = activateAlarm(globalUser, datetime.now().strftime("%d-%m-%Y %H:%M:%S"), 'Smoke')
            threading.Thread(target=self.activatingAlarmThread, args=['Smoke']).start()
            ###############################################################

            myAlarmAppObj.alarm_type_text = "Smoke"
            self.smokeFound = True
            print self.smokeresult
            self.lastscreen = "livealarmscreen"
            self.root.current = "livealarmscreen"

        elif self.smokeresult == "false" and self.smokeOff and self.smokecancelButton1:
            self.smokeOn = False
            # if self.cancelButton != 'Hey1':
            #     os.system
            #         'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))

            self.smokecancelButton = False
            self.smokecancelButton1 = False
            print self.smokeresult
        elif self.smokecancelButton:
            self.smokecancelButton = ""
            self.smokecancelButton1 = True

            # os.system(
            #     'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(0)" -g' % (globalIpAddress))
            if self.smokeTimer > 30:
                self.sirenDeactivate()

            buzzerActive = False
            # if serverOK:
            #     deactivateAlarm(self.alarmID)
            threading.Thread(target=self.deactivatingAlarmThread).start()

            self.smokeFound = False
            self.smokeTimer = 0

        if self.smokeTimer == 30:
            print "PLAY SIREN"
            # os.system(
            #     'curl --user admin:arne123 --data " " "http://%s:8083/ZWaveAPI/Run/devices[2].instances[0].SwitchBinary.Set(255)" -g' % (globalIpAddress) % (globalIpAddress))
            buzzerActive = False
            self.sirenActivate()

    def changeLanguage(self, language):
        print "changeLanguage"
        screenList = [self.settingscreen, self.alarmscreen, self.securityscreen,
                      self.changepinscreen, self.changewebpinscreen, self.clockscreen,
                      self.ethernetwifi, self.wifiscreen, self.ethernetscreen, self.language,
                      self.serversettings, self.firmwarescreen, self.livealarmscreen, self.burglaryalarmscreen]
        conversion = LanguageConversion()
        for screen in screenList:
            if language == 'English':
                # screen.conversion.languageConversion(screen.conversion.englishLanguageDict)
                # conversion.languageConversion(self.objectList, conversion.englishLanguageDict)
                languageDict = conversion.englishLanguageDict
            elif language == "Norwegian":
                # screen.conversion.languageConversion(screen.conversion.norwainLanguageDict)
                # conversion.languageConversion(self.objectList, conversion.norwainLanguageDict)
                languageDict = conversion.norwainLanguageDict

            conversion.languageConversion(screen.objectList, languageDict)

    def errorPopup(self, errorMessage=None):
        global popup
        content = BoxLayout(orientation='vertical')
        content_cancel = Button(text='OK', size_hint_y=None, height=40)
        content_label = Label(text=errorMessage)
        content.add_widget(content_label)
        content.add_widget(content_cancel)
        popup = Popup(title='Error',
                      size_hint=(None, None), size=(400, 200),
                      content=content, disabled=False, auto_dismiss=True)
        content_cancel.bind(on_release=popup.dismiss)

        ########################################################################
        ### LANGUAGE HANDLING ###
        #########################
        conversion = LanguageConversion()
        if myAlarmAppObj.language.lspnr.text == "English":
            languageDict = conversion.englishLanguageDict
        elif myAlarmAppObj.language.lspnr.text == "Norwegian":
            languageDict = conversion.norwainLanguageDict

        objectList = [content_label, content_cancel, popup]
        conversion.languageConversion(objectList, languageDict)

        #########################################################################

        popup.open()


class ssidButton(Button):

    def __init__(self, cellname, **kwargs):
        super(ssidButton, self).__init__(**kwargs)
        self.cell = cellname

    def enterPasswordEntryPopup(self, modify=False):
        global popup, ip

        def cancel(event):
            global popup
            popup.dismiss()
            return

        def connect(event):
            global activateThread
            global popup

#             def connecting():
#                 global stop
#                 inalive = True
#                 while inalive:#True:
# ##                    if stop.is_set():
# ##                        return
#                     connectnet()
#                     time.sleep(1)
#                     inalive = False

            def schemeActivation():
                global popup
                try:
                    self.scheme.activate()
                    myAlarmAppObj.get_details()
                    popup.dismiss()
                    print "Done"
                except:
                    self.scheme.delete()
                    print "WRONG PASSWORD"
                    popup.dismiss()
                    myAlarmAppObj.errorPopup(errorMessage='Wrong Password...!!!')


            def connectnet():
                global stopper

                # myAlarmAppObj.wifiscreen.awai.add_widget(Button(text="Added1"))
                try:
                    print "ACTIVATING"
                    # self.scheme.activate()
                    # popup.dismiss()
                    threading.Thread(target=schemeActivation).start()
                    self.connectncancel_connect.text = "Wait.."
                    self.connectncancel_connect.disabled = True
                    self.connectncancel_cancel.disabled = True
                    myAlarmAppObj.menuscreen.wifiImage.source = "images/wifiOn.jpg"
                    print "ACTIVATED"

                except:
                    # self.scheme.delete()
                    # print "WRONG PASSWORD"
                    # popup.dismiss()
                    # myAlarmAppObj.errorPopup(errorMessage='Wrong Password...!!!')
                    myAlarmAppObj.menuscreen.wifiImage.source = "images/wifiOff.jpg"

                ##                iptext = commands.getoutput("/sbin/ifconfig").split("wlan0")[1].split("\n")[1].split()[1][5:]
                # myAlarmAppObj.wifiscreen.awai.add_widget(Button(text=str(iptext)))
                myAlarmAppObj.get_details()
##                myAlarmAppObj.ethernetwifi.ipg.text = "IP ADDRESS : " + myAlarmAppObj.ipAddress


            self.password = self.network_password.text
            if modify:
                self.scheme.delete()
                self.iptext = ip.text
                self.gwtext = gateway.text
                self.nmtext = netmask.text
                print self.password, self.iptext, self.gwtext, self.nmtext
            self.scheme = Scheme.for_cell('wlan0', self.schemeName, self.cell, self.password)
            self.scheme.save()
            connectnet()
            # activateThread = threading.Thread(target=connecting)
            # activateThread.daemon = True
            # activateThread.start()

##            time.sleep(5)

##            try:
##                self.scheme.activate()
##            except:
##                None

        connectncancel = BoxLayout()

        self.connectncancel_cancel = Button(text="Cancel", on_release=cancel)
        self.connectncancel_connect = Button(text="Connect", on_release=connect)

        connectncancel.add_widget(self.connectncancel_cancel)
        connectncancel.add_widget(self.connectncancel_connect)
        passwordEntryContent = BoxLayout(orientation='vertical')
        passwordEntryContent.add_widget(Label(text='Password'))
        self.network_password = TextInput(multiline=False, password=False)
        passwordEntryContent.add_widget(self.network_password)
        windowSize = (300, 200)



        def defaultInterfaceFile(e):
            fileName = "/etc/network/interfaces"
            fileNew = "/etc/network/interfacesNew"


            with open(fileName, "r") as f:
                line = f.readline()
                with open(fileNew, "w") as fnew:
                    while line:
                        fnew.write(line)
                        line = f.readline()

            found = False
            count = 0
            with open(fileNew, "r") as f:
                line = f.readline()
                with open(fileName, "w") as fnew:
                    while line:
                        if line == "allow-hotplug wlan0\n":
                            found = True
                            count = 0
                            fnew.write(line)

                        if found:
                            count+=1

                        if count <= 7 and found:
                            None
                        else:
                            fnew.write(line)

                        line = f.readline()
                        # time.sleep(0.5)
            commands.getoutput("sudo rm %s" % (fileNew))

        def editInterfaceFile(e):
            defaultInterfaceFile(None)
            ipaddressText = "addresss " + ipaddress.text
            netmaskText = "netmask 255.255.255.0"
            networkText = "network " + netmask.text
            broadcastText = "broadcast 192.168.0.255"
            gatewayText = "gateway " + gateway.text

            fileName = "/etc/network/interfaces"
            fileNew = "/etc/network/interfacesNew"


            with open(fileName, "r") as f:
                line = f.readline()
                with open(fileNew, "w") as fnew:
                    while line:
                        fnew.write(line)
                        line = f.readline()

            with open(fileNew, "r") as f:
                line = f.readline()
                with open(fileName, "w") as fnew:
                    while line:
                        fnew.write(line)
                        if line == "allow-hotplug wlan0\n":
                            print "FOUND"
                            fnew.write("iface wlan0 inet static\n")
                            fnew.write(ipaddressText + "\n")
                            fnew.write(netmaskText + "\n")
                            fnew.write(networkText + "\n")
                            fnew.write(broadcastText + "\n")
                            fnew.write(gatewayText + "\n")
                        line = f.readline()
                        # time.sleep(0.5)
            commands.getoutput("sudo rm %s" % (fileNew))


        if modify:
            b = BoxLayout()#on_touch_down = myAlarmAppObj.resetTimer)
            a = AnchorLayout()
            t = TextInput(text=self.network_password.text, size_hint_x=1, password=False, size_hint_y=.8)
            a.add_widget(t)
            b1 = BoxLayout(spacing='20dp')
            b1_passwordLabel = Label(text="Password", size_hint_x=.5)
            b1.add_widget(b1_passwordLabel)
            b1.add_widget(a)
            # b1.add_widget(Button(height = 10,text = "OK"))

            b3 = BoxLayout(padding="5dp", spacing="20dp")
            cancel = Button(text="Cancel")
            save = Button(text="Save")
            b3.add_widget(cancel)
            b3.add_widget(save)

            b2 = BoxLayout()
            b2.add_widget(Widget(size_hint_x=1))
            b2.add_widget(CheckBox(size_hint_x=.5))
            b2_showPasswordLabel = Label(text="Show Password", size_hint_x=.5)
            b2.add_widget(b2_showPasswordLabel)
            b2.add_widget((Widget(size_hint_x=1)))
            bm = BoxLayout(orientation='vertical')
            bm.add_widget(b1)
            bm.add_widget(b2)
            bm.add_widget(b3)
            tabbed_panel = TabbedPanel()
            # tabbed_panel.do_default_tab = False
            content = BoxLayout(orientation='vertical')
            # content.add_widget(Label(markup = True,text = "[b] Device MAC address : [/b]" + self.wifimacaddress))
            content.add_widget(bm)
            tabbed_panel.default_tab_content = content

            tabbed_panel.default_tab_text = "Wifi"
            b.add_widget(tabbed_panel)

            ######------ipv4tab-------#########

            ipv4tab = TabbedPanelItem(text="IPV4 Settings")
            ipv4tabcontent = BoxLayout(orientation='vertical')#,on_touch_down = myAlarmAppObj.resetTimer)
            b1 = BoxLayout(padding="10dp", size_hint_y=1)
            l = Label(text="{}".format(myAlarmAppObj.ipAddress))
            s = Spinner(text="Automatic(DHCP)", values=["Manual", "Automatic(DHCP)"])  # on_text
            b1.add_widget(s)
            b1.add_widget(l)

            b2 = BoxLayout(padding='2dp', spacing='5dp', size_hint_y=1)
            b21 = BoxLayout(orientation='vertical')
            iplabel = Label(text="Address")
            ipaddress = TextInput(multiline=False)
            b21.add_widget(iplabel)
            b21.add_widget(ipaddress)

            # b22 = BoxLayout(orientation = "vertical")
            b22 = BoxLayout(orientation='vertical')
            nmlabel = Label(text="Netmask")
            netmask = TextInput(multiline=False)
            b22.add_widget(nmlabel)
            b22.add_widget(netmask)

            # b23 = BoxLayout(orientation="vertical")
            b23 = BoxLayout(orientation='vertical')
            gwlabel = Label(text="Gateway")
            gateway = TextInput(multiline=False)
            b23.add_widget(gwlabel)
            b23.add_widget(gateway)

            b2.add_widget(b21)
            b2.add_widget(b22)
            b2.add_widget(b23)

            ipv4tabcontent.add_widget(b1)
            ipv4tabcontent.add_widget(b2)
            ipv4tabcontent_saveButton = Button(text="Save", size_hint_y=.5, on_release=editInterfaceFile)
            ipv4tabcontent.add_widget(ipv4tabcontent_saveButton)

            ipv4tab.content = ipv4tabcontent
            tabbed_panel.add_widget(ipv4tab)

            windowSize = (500, 250)
            popup = Popup(title=self.text,
                          size_hint=(None, None), size=windowSize,
                          # pos=(50, 50),
                          # pos_hint={'x':0,'top':1},
                          pos_hint={'middle': 1, 'top': 1},
                          content=b, disabled=False, auto_dismiss=True)

            ########################################################################
            ### LANGUAGE HANDLING ###
            #########################
            conversion = LanguageConversion()
            if myAlarmAppObj.language.lspnr.text == "English":
                languageDict = conversion.englishLanguageDict
            elif myAlarmAppObj.language.lspnr.text == "Norwegian":
                languageDict = conversion.norwainLanguageDict

            objectList = [b1_passwordLabel, save, cancel, b2_showPasswordLabel, iplabel, nmlabel, gwlabel, ipv4tabcontent_saveButton, popup]
            conversion.languageConversion(objectList, languageDict)

            #########################################################################

            return popup
            ###################################

        passwordEntryContent.add_widget(connectncancel)
        # print(self.root,self.root.h,self.parent.width)
        popup = Popup(title=self.text,
                      size_hint=(None, None), size=windowSize,
                      # pos=(50, 50),
                      # pos_hint={'x':0,'top':1},
                      # pos_hint={'right': 1, 'top': 1},
                      content=passwordEntryContent, disabled=False, auto_dismiss=False)

        ########################################################################
        ### LANGUAGE HANDLING ###
        #########################
        conversion = LanguageConversion()
        if myAlarmAppObj.language.lspnr.text == "English":
            languageDict = conversion.englishLanguageDict
        elif myAlarmAppObj.language.lspnr.text == "Norwegian":
            languageDict = conversion.norwainLanguageDict

        objectList = [self.connectncancel_cancel, self.connectncancel_connect, popup]
        conversion.languageConversion(objectList, languageDict)

        #########################################################################

        return popup

    def on_release(self):
        global popup
        specialList = string.printable.split("Z")[-1]
        self.schemeName = self.text

        for char in specialList:
            if char in self.schemeName:
                self.schemeName = self.schemeName.split(char)[0]
                break

        self.scheme = Scheme.find('wlan0', self.schemeName)
        print "schemeName:", self.schemeName, self.scheme
        if not self.scheme:  # Scheme.find('wlan0', schemeName):
            print "Creating New Scheme"
            self.passwordPopup = self.enterPasswordEntryPopup()
            self.passwordPopup.open()
            #######################################
            # scheme = Scheme.for_cell('wlan0', schemeName, cell, 'pikkme@123')

        # elif self.scheme.options.get('wpa-ssid') != self.cell.ssid:

        else:
            print "Scheme Already Exists"

            def deletingScheme():
                print "DELETING"
                commands.getoutput("sudo ifdown wlan0")  # killall dhclient")
                self.scheme.delete()
                commands.getoutput("sudo ifconfig wlan0 up")  # killall dhclient")
                popup.dismiss()
                print "DELETED"

            def forgetnetwork(event):
                global popup
                self.scheme = Scheme.find('wlan0', self.schemeName)
                threading.Thread(target=deletingScheme).start()
                # commands.getoutput("sudo ifdown wlan0")#killall dhclient")
                # self.scheme.delete()
                # commands.getoutput("sudo ifconfig wlan0 up")  # killall dhclient")
                self.content_forget.disabled = True
                self.content_modify.disabled = True
                popup.auto_dismiss = False
                myAlarmAppObj.menuscreen.wifiImage.source = "images/wifiOff.jpg"


            def modifynetwork(event):
                global popup
                popup.dismiss()
                self.passwordPopup = self.enterPasswordEntryPopup(modify=True)
                self.passwordPopup.open()
                # Open(None)

            # self.scheme = Scheme.find('wlan0', self.schemeName)

            # self.activate()
            ##############################################3
            content = BoxLayout(orientation='vertical')#, on_touch_down=self.resetTimer, padding=10, spacing=10)
            # content_cancel = Button(text='OK', size_hint_y=None, height=40)
            self.content_forget = Button(text='Forget Network', on_release=forgetnetwork)
            self.content_modify = Button(text='Modify Network', on_release=modifynetwork)
            content.add_widget(self.content_forget)
            content.add_widget(self.content_modify)
            popup = Popup(title=self.text,
                          size_hint=(None, None), size=(300, 200),
                          content=content, disabled=False, auto_dismiss=True)

            ########################################################################
            ### LANGUAGE HANDLING ###
            #########################
            conversion = LanguageConversion()
            if myAlarmAppObj.language.lspnr.text == "English":
                languageDict = conversion.englishLanguageDict
            elif myAlarmAppObj.language.lspnr.text == "Norwegian":
                languageDict = conversion.norwainLanguageDict

            objectList = [self.content_forget, self.content_modify, popup]
            conversion.languageConversion(objectList, languageDict)

            #########################################################################

            popup.open()

##    def activate(self):
##        self.scheme.activate()
##        print ("ACTIVATED")

    def resetTimer(self,x,y):
        print x,y
        myAlarmAppObj.resetTimer()

class MenuScreen(Screen):
    manual = ObjectProperty(None)
    flame = ObjectProperty(None)
    money = ObjectProperty(None)
    plum = ObjectProperty(None)
    gas = ObjectProperty(None)
    shield = ObjectProperty(None)
    FlameActive = BooleanProperty(False)
    MoneyActive = BooleanProperty(False)
    PlumActive = BooleanProperty(False)
    GasActive = BooleanProperty(False)
    ShieldActive = BooleanProperty(False)
    counter = 0
    activeShieldSignal = BooleanProperty(False)

    wifiImage = ObjectProperty()

    def burglaryTimer(self, dt):
        # counter = 0
        # while self.ShieldActive:
            self.counter+=1
            if self.counter == 300: ### ON AFTER 5MINS ###
                myAlarmAppObj.alarmscreen.burglaryCheckBox.active = True
                Clock.unschedule(self.burglaryTimer)


    def ActiveShield(self):
        self.activeShieldSignal = True
        self.ShieldActive = not self.ShieldActive
        # if self.ShieldActive:

    def ActivatingShield(self):
        if self.ShieldActive:
            print ("Activating Burglary")
            # threading.Thread(target=self.burglaryTimer).start()
            Clock.schedule_interval(self.burglaryTimer, 1)
            self.shield.source = "images/shieldg4.png"
        else:
            self.counter = 0
            self.shield.source = "images/shieldr4.png"
            Clock.unschedule(self.burglaryTimer)
            myAlarmAppObj.alarmscreen.burglaryCheckBox.active = False


    def ActiveFlame(self):

        self.FlameActive = not self.FlameActive
        if self.FlameActive:
            self.flame.source = "images/flamesg4.png"
            myAlarmAppObj.ActivateFireSiren()
            print("ActivateFire")
            # myAlarmAppObj.alarm_type_text = "Flame"
        else:
            myAlarmAppObj.DeactivateFireSiren = True
            self.flame.source = "images/flamesr4.png"


    def ActiveMoney(self):
        self.MoneyActive = not self.MoneyActive
        if self.MoneyActive:
            myAlarmAppObj.ActivateBurglarySiren()
            print("ActivateBurglary")
            self.money.source = "images/moneyg4.png"
            # myAlarmAppObj.alarm_type_text = "Burglary"
        else:
            myAlarmAppObj.DeactivateBurglarySiren = True
            self.money.source = "images/moneyr4.png"

    def ActivePlum(self):
        self.PlumActive = not self.PlumActive
        if self.PlumActive:
            myAlarmAppObj.ActivateFloodSiren()
            self.plum.source = "images/plumg4.png"
        else:
            myAlarmAppObj.DeactivateFloodSiren = True
            self.plum.source = "images/plumr4.png"

    def ActiveGas(self):
        self.GasActive = not self.GasActive
        if self.GasActive:
            myAlarmAppObj.ActivateSmokeSiren()
            self.gas.source = "images/gasg4.png"
        else:
            myAlarmAppObj.DeactivateSmokeSiren = True
            self.gas.source = "images/gasr4.png"


if __name__ == '__main__':
    from kivy.core.window import Window
    Window.clearcolor = (.15, .15, .15, 1)
    myAlarmAppObj = MyAlarmApp()
    myAlarmAppObj.run()