Exemple #1
0
    def __init__(self):
        '''
        Constructor. Creates the GUI (window and containing components).
        '''
        log.debug("ClientGui started")

        dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
        bus = dbus.SessionBus()
        self.queue = shared.queueinterface.get_interface(bus)
        self.mainloop = gobject.MainLoop()

        hildon.Program.__init__(self)
        self.window = hildon.Window()
        self.window.set_title("ClientGui")
        self.window.set_size_request(800,480)
        self.add_window(self.window)

        # create the database
        db = ClientDatabase(self.queue)
        self.db = shared.data.create_database(db)
        # create message dispatcher
        self.message_dispatcher = shared.messagedispatcher.MessageDispatcher(bus, db)
        # connect the dispatcher to database
        self.db.dispatcher = self.message_dispatcher

        self.mapobjecthandler = MapObjectHandler(self.db, self.queue)
        self.textmessagehandler = TextMessageHandler(self.db, self.queue)

        self.message_dispatcher.connect_to_type(MessageType.object, self.mapobjecthandler.handle)
        self.message_dispatcher.connect_to_type(MessageType.text, self.textmessagehandler.handle)
        
        self.journalhandler = JournalHandler(self.db, self.queue)
        self.message_dispatcher.connect_to_type(MessageType.journal, self.journalhandler.handle)

        # create gui
        self.create_gui()
Exemple #2
0
class ClientGui(hildon.Program):
    queue = None
    db = None

    def __init__(self):
        '''
        Constructor. Creates the GUI (window and containing components).
        '''
        log.debug("ClientGui started")

        dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
        bus = dbus.SessionBus()
        self.queue = shared.queueinterface.get_interface(bus)
        self.mainloop = gobject.MainLoop()

        hildon.Program.__init__(self)
        self.window = hildon.Window()
        self.window.set_title("ClientGui")
        self.window.set_size_request(800,480)
        self.add_window(self.window)

        # create the database
        db = ClientDatabase(self.queue)
        self.db = shared.data.create_database(db)
        # create message dispatcher
        self.message_dispatcher = shared.messagedispatcher.MessageDispatcher(bus, db)
        # connect the dispatcher to database
        self.db.dispatcher = self.message_dispatcher

        self.mapobjecthandler = MapObjectHandler(self.db, self.queue)
        self.textmessagehandler = TextMessageHandler(self.db, self.queue)

        self.message_dispatcher.connect_to_type(MessageType.object, self.mapobjecthandler.handle)
        self.message_dispatcher.connect_to_type(MessageType.text, self.textmessagehandler.handle)
        
        self.journalhandler = JournalHandler(self.db, self.queue)
        self.message_dispatcher.connect_to_type(MessageType.journal, self.journalhandler.handle)

        # create gui
        self.create_gui()
    
    def build_icon(self, label, icon, box_type = "v"):
        image = gtk.Image()
        image.set_from_file(icon)

        if box_type == "v":
            vbox = gtk.VBox()
            vbox.add(image)
            vbox.add(gtk.Label(label))
            return vbox
        else:
            hbox = gtk.HBox(True, 0)
            hbox.add(image)
            hbox.add(gtk.Label(label))
            return hbox

    def create_gui(self):
        # Creates a empty list that contains previous screens
        self.prev_page = []

        # A dict containing all the containers (used for hiding/showing) 
        self.screens = {}

        # A dict containing all the buttons to show/hide
        self.menu_buttons = {}

        # Panels
        panels = gtk.HBox(False, 0)
        self.window.add(panels)

        # Left menu
        vbox = gtk.VBox(False,0)
        panels.pack_start(vbox, False, False, 0)
        vbox.set_size_request(150,350)

        # Buttons (menu)
        self.mission_button = BlinkToggleButton()
        self.mission_button.add(self.build_icon("Uppdrag",
                                           "icons/emblem-important.png"))
        self.mission_button.connect("clicked", self.show_mission)
        self.mapobjecthandler.connect("got-new-mission", self.new_mission)
        self.menu_buttons["mission"] = self.mission_button

        add_object_button = gtk.ToggleButton()
        add_object_button.add(self.build_icon("Skapa",
                                              "icons/list-add.png"))
        add_object_button.connect("clicked", self.show_add_object)
        self.menu_buttons["add_object"] = add_object_button

        contacts_button = gtk.ToggleButton()
        contacts_button.add(self.build_icon("Kontakter",
                                            "icons/x-office-address-book.png"))
        contacts_button.connect("clicked", self.show_contacts)
        self.menu_buttons["contacts"] = contacts_button

        self.messages_button = BlinkToggleButton()
        self.messages_button.add(self.build_icon("Meddelande",
                                                 "icons/internet-mail.png"))
        self.messages_button.connect("clicked", self.show_messages) 
        self.textmessagehandler.connect("got-new-message", self.new_message)
        self.menu_buttons["messages"] = self.messages_button

        vbox.add(self.mission_button)
        vbox.add(add_object_button)
        vbox.add(contacts_button)
        vbox.add(self.messages_button)
        
        if config.client.type == 'commander':
            patient_journal_message = gtk.ToggleButton()
            patient_journal_message.add(self.build_icon("Patient-\njournal",
                                                        "icons/text-x-generic.png"))
            patient_journal_message.connect("clicked", self.show_patient_journal_message) 
            #self.textmessagehandler.connect("got-new-message", self.new_message)
            self.menu_buttons["patient_journal_message"] = patient_journal_message
            vbox.add(patient_journal_message)      

        # Right panel
        vbox_right = gtk.VBox(False, 0)
        panels.pack_start(vbox_right, True, True, 0)
        
        # adding the notification bar
        self.notifications = NotificationScreen()
        vbox_right.pack_start(self.notifications, False, False, 0)
        self.screens["notifications"] = self.notifications

        # add the map screen
        self.map = MapScreen(self.db)
        self.map.connect("object-clicked", self.change_object)
        vbox_right.pack_start(self.map, True, True, 0)
        self.screens["map"] = self.map

        # add the alarm screen
        self.alarm_screen = AlarmScreen(self.db)
        self.alarm_screen.connect("okbutton-alarm-clicked",
                                  self.back_button_function) 
        vbox_right.pack_start(self.alarm_screen, True, True, 0)
        self.screens["alarm"] = self.alarm_screen

        # adding messages screen
        self.message_screen = InboxScreen(self.db)
        vbox_right.pack_start(self.message_screen, True, True, 0)
        self.screens["message"] = self.message_screen
        
        self.new_message_screen = NewMessageScreen(self.db)
        self.new_message_screen.connect("okbutton_clicked_new_message",
                                        self.back_button_function) 
        vbox_right.pack_start(self.new_message_screen, True, True, 0)
        self.screens["new_message"] = self.new_message_screen
        
        self.outbox_screen = OutboxScreen(self.db)
        vbox_right.pack_start(self.outbox_screen, True, True, 0)
        self.screens["output"] = self.outbox_screen

        # add the obstacle screen
        self.obstacle_screen = ObstacleScreen(self.db)
        self.obstacle_screen.connect("okbutton-obstacle-clicked",
                                     self.back_button_function)
        vbox_right.pack_start(self.obstacle_screen, True, True, 0)
        self.screens["obstacle"] = self.obstacle_screen
        
        # add the change obstacle screen
        self.change_obstacle_screen = ChangeObstacleScreen(self.db)
        vbox_right.pack_start(self.change_obstacle_screen, True, True, 0)
        self.screens["change_obstacle"] = self.change_obstacle_screen
        
        # add the create_mission screen
        self.mission_screen = MissionScreen(self.db)
        self.mission_screen.connect("okbutton-mission-clicked",
                                    self.back_button_function)
        vbox_right.pack_start(self.mission_screen, True, True, 0)
        self.screens["make_mission"] = self.mission_screen

        # add the change mission screen
        self.change_mission_screen = ChangeMissionScreen(self.db)
        vbox_right.pack_start(self.change_mission_screen, True, True, 0)
        self.screens["change_mission"] = self.change_mission_screen
        
        self.unit_screen = UnitScreen()
        vbox_right.pack_start(self.unit_screen, True, True, 0)
        self.screens["view_unit"] = self.unit_screen

        self.faq_screen = FAQScreen(self.db)               
        vbox_right.pack_start(self.faq_screen, True, True, 0)
        self.screens["faq"] = self.faq_screen
        
        self.info_screen = MissionInfoScreen(self.db)               
        vbox_right.pack_start(self.info_screen, True, True, 0)
        self.screens["info"] = self.info_screen

        self.patient_journal_screen = PatientJournalScreen(self.db, self.queue)
        self.patient_journal_screen.connect("okbutton_clicked_PatientJournalScreen",
                                            self.back_button_function)               
        vbox_right.pack_start(self.patient_journal_screen, True, True, 0)
        self.screens["patient_journal"] = self.patient_journal_screen        

        # add the contact_screen and their menu
        self.contact_screen = ContactScreen(self.db)
        vbox_right.pack_start(self.contact_screen, True, True, 0)
        self.screens["contact"] = self.contact_screen
        
        # Videocamera
        self.cam_screen = CamScreen(self.db)
        self.cam_screen.button.connect("clicked", self.back_button_function)
        vbox_right.pack_start(self.cam_screen, True, True, 0)
        self.screens["camera"] = self.cam_screen
        
        #Contact menu
        self.contact_menu = gtk.HBox(False, 0)
        self.contact_menu.set_size_request(0, 60)
        vbox_right.pack_start(self.contact_menu, False, False, 0)
        self.screens["contact_menu"] = self.contact_menu
        call = gtk.Button("Röstsamtal")
        call.connect("clicked", self.sending_voip)
        video = gtk.Button("Videosamtal")
        video.connect("clicked", self.sending_vvoip)
        self.contact_menu.add(call)
        self.contact_menu.add(video)

        # Mission buttons and their menu
        self.mission_menu = gtk.HBox(True, 0)
        self.mission_menu.set_size_request(0, 60)
        vbox_right.pack_start(self.mission_menu, False, False, 0)
        self.screens["mission_menu"] = self.mission_menu

        info_button = gtk.Button()
        info_button.add(self.build_icon("Mina Uppdrag",
                                        "icons/emblem-important.png", "h"))
        info_button.connect("clicked", self.show_mission_info)
        journal_button = gtk.Button()
        journal_button.add(self.build_icon("Patient-\njournal",
                                           "icons/text-x-generic.png", "h"))
        journal_button.connect("clicked", self.show_journals)
        faq_button = gtk.Button()
        faq_button.add(self.build_icon("FAQ","icons/help-browser.png", "h"))
        faq_button.connect("clicked", self.show_faq)
        self.mission_menu.add(info_button)
        #self.mission_menu.add(status_button)
        self.mission_menu.add(journal_button)
        self.mission_menu.add(faq_button)
        
        #Message buttons and their menu
        self.message_menu = gtk.HBox(False, 0)
        self.message_menu.set_size_request(0, 60)
        vbox_right.pack_start(self.message_menu, False, False, 0)
        self.screens["message_menu"] = self.message_menu
        
        new_mess = gtk.Button("Nytt")
        new_mess.connect("clicked", self.create_new_message)
        inbox = gtk.Button("Inkorg")
        inbox.connect("clicked", self.show_inbox)
        outbox = gtk.Button("Utkorg")
        outbox.connect("clicked", self.show_outbox)
        self.message_menu.add(new_mess)
        self.message_menu.add(inbox)
        self.message_menu.add(outbox)
        
        self.patient_journal_message_screen = PatientJournalMessageScreen(self.db)
        self.journalhandler.connect("got-new-journal-request", self.patient_journal_message_screen.add_request)
        self.journalhandler.connect("got-new-journal-response",
                                    self.screens["patient_journal"].got_journal_response)
        vbox_right.pack_start(self.patient_journal_message_screen, True, True, 0)
        self.screens["patient_journal_message_screen"] = self.patient_journal_message_screen
        
        vbox2 = gtk.VBox(False,0)
        #panels.pack_start(vbox2, False, False, 0)
        vbox2.set_size_request(150,0)
        
        #self.activities = gtk.VBox(False,0)
        self.activities = Activities(self.db)
        vbox2.pack_start(self.activities, False, False, 0)
        self.screens["act"] = self.activities 
        #self.activities = Activities(self.db)
             
        #self.ac = Activities(self.db)
        #self.activities.add(self.ac)  

        # Add object buttons and their menu
        self.add_object_menu = gtk.HBox(True, 0)
        self.add_object_menu.set_size_request(0, 60)
        vbox_right.pack_start(self.add_object_menu, False, False, 0)
        self.screens["add_object_menu"] = self.add_object_menu
        
        create_alarm_button = gtk.Button("Larm")
        create_alarm_button.connect("clicked", self.create_alarm)
        create_obstacle_button = gtk.Button("Hinder")
        create_obstacle_button.connect("clicked", self.create_obstacle)
        self.add_object_menu.add(create_alarm_button)
        self.add_object_menu.add(create_obstacle_button)
        if config.client.type == 'commander':
            create_mission_button = gtk.Button("Uppdrag")
            create_mission_button.connect("clicked", self.create_mission)
            self.add_object_menu.add(create_mission_button)

        # add back- and ok-button (used in alarmscreen, obstaclescreen etc)
        self.buttons_box = gtk.HBox(True, 0)
        self.buttons_box.set_size_request(0, 60)
        self.screens["buttons"] = self.buttons_box
        
        back_button = gtk.Button()
        back_button.add(self.build_icon("Bakåt", "icons/edit-undo.png", "h"))
        self.buttons_box.pack_start(back_button)
        back_button.connect("clicked", self.back_button_function)

        ok_button = gtk.Button()
        ok_button.add(self.build_icon("OK", "icons/list-add.png", "h"))
        ok_button.connect("clicked", self.ok_button_function)
        ok_button.set_flags(gtk.CAN_DEFAULT)
        self.buttons_box.pack_start(ok_button)
        
        vbox_right.pack_start(self.buttons_box, False, False, 0)
        
        self.back_button_box = gtk.HBox(True, 0)
        self.back_button_box.set_size_request(0, 60)
        self.screens["back_button_box"] = self.back_button_box
        
        back_button2 = gtk.Button()
        back_button2.add(self.build_icon("Bakåt", "icons/edit-undo.png", "h"))
        self.back_button_box.pack_start(back_button2)
        back_button2.connect("clicked", self.back_button_function)
        
        vbox_right.pack_start(self.back_button_box, False, False, 0)
        
        vbox_right.pack_start(self.create_pj_message_buttons(), False, False, 0)

        vbox_right.pack_start(self.create_pj_request_buttons(), False, False, 0)

        vbox_right.pack_start(self.create_change_buttons(), False, False, 0)

        self.window.connect("destroy", lambda event: self.mainloop.quit())
        self.window.connect("key-press-event", self.on_key_press)
        self.window.connect("window-state-event", self.on_window_state_change)

        # Change to default True?
        self.window_in_fullscreen = False
        log.info("ClientGui created")

    def create_pj_message_buttons(self):
        pj_button_box = gtk.HBox(False, 10)
        pj_button_box.set_size_request(0, 60)
        self.screens["pj_button_box"] = pj_button_box
        
        
        no_button = gtk.Button("Neka")
        no_button.connect("clicked", self.no_button_function)
        no_button.set_flags(gtk.CAN_DEFAULT)
        pj_button_box.pack_start(no_button)
        
        ok_button = gtk.Button("Bevilja")
        ok_button.connect("clicked", self.ok_button_function)
        ok_button.set_flags(gtk.CAN_DEFAULT)
        pj_button_box.pack_start(ok_button)
        
        return pj_button_box

    def create_pj_request_buttons(self):
        pj_button_box = gtk.HBox(False, 10)
        pj_button_box.set_size_request(0, 60)
        self.screens["pj_request_button_box"] = pj_button_box
        
        back_button = gtk.Button()
        back_button.add(self.build_icon("Bakåt", "icons/edit-undo.png", "h"))
        pj_button_box.pack_start(back_button)
        back_button.connect("clicked", self.back_button_function)

        ok_button = gtk.Button("Begär ny journal")
        ok_button.connect("clicked", self.ok_button_function)
        ok_button.set_flags(gtk.CAN_DEFAULT)
        pj_button_box.pack_start(ok_button)
        
        return pj_button_box

    def create_change_buttons(self):
        # add back-, change- and delete-button (used in ChangeObstacleScreen etc)
        self.change_buttons = gtk.HBox(False, 0)
        self.change_buttons.set_size_request(0, 60)
        self.screens["change_buttons"] = self.change_buttons
        
        change_back_button = gtk.Button()
        change_back_button.add(self.build_icon("Bakåt", 
                                               "icons/edit-undo.png", "h"))
        self.change_buttons.pack_start(change_back_button)
        change_back_button.connect("clicked", self.back_button_function)
        
        delete_button = gtk.Button()
        delete_button.add(self.build_icon("Ta bort", 
                                          "icons/emblem-unreadable.png", "h"))
        delete_button.connect("clicked", self.delete_button_function)
        delete_button.set_flags(gtk.CAN_DEFAULT)
        self.change_buttons.pack_start(delete_button)

        change_button = gtk.Button()
        change_button.add(self.build_icon("Spara ändringar", 
                                          "icons/document-save.png", "h"))
        change_button.connect("clicked", self.change_button_function)
        change_button.set_flags(gtk.CAN_DEFAULT)
        self.change_buttons.pack_start(change_button)
        
        return self.change_buttons

    def new_message(self,event):
        print "*****************"
        print "GOT NEW MESSAGE!!"
        print "*****************"
        
        self.messages_button.set_attention(True)
        shared.util.set_color(0,255,0)
        shared.util.play_uri("snd/mail3b.wav")
        label = self.messages_button.get_child()
        label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("green"))
        
    def new_mission(self,event):
        shared.util.set_color(255,0,0)
        self.mission_button.set_attention(True)

    def change_object(self, event, object):
        keys = []
        for key in self.screens.keys():
                screen = self.screens[key]
                if screen.props.visible:
                    keys.append(key)
        self.prev_page.append(keys)
        if object.__class__ == POIData:
            # show the changeobstaclescreen
            self.change_obstacle(object)
        elif object.__class__ == MissionData:
            self.change_mission(object)
        elif object.__class__ == UnitData:
            self.view_unit(object)
            
    def change_obstacle(self, poi):
        self.show(["change_obstacle", "change_buttons"])
        self.screens["change_obstacle"].set_entries(poi)
        
    def change_mission(self, mission):
        self.show(["change_mission", "change_buttons"])
        self.screens["change_mission"].set_entries(mission)
        
    def view_unit(self, unit):
        self.show(["view_unit", "back_button_box"])
        self.screens["view_unit"].set_entries(unit)

    def sending_voip(self, event):
        msg = shared.data.Message(self.controller.name, 
                                  self.screens["contact"].name,
                                  type=shared.data.MessageType.voip, 
                                  subtype=shared.data.VOIPType.request,
                                  unpacked_data={"ip": get_ip(), "port": 5432,
                                                 "class": "dict"},
                                  prio = 5)
        self.queue.enqueue(msg.packed_data, msg.prio)
        self.out_call_popup(msg)
        
    def sending_vvoip(self, event):
        msg = shared.data.Message(self.controller.name, 
                                  self.screens["contact"].name,
                                  type=shared.data.MessageType.vvoip, 
                                  subtype=shared.data.VVOIPType.request,
                                  unpacked_data={"ip": get_ip(), "port1": 5432, 
                                                 "port2": 5434, "class": "dict"},
                                  prio = 5)
        self.queue.enqueue(msg.packed_data, msg.prio)
        self.out_call_popup(msg)
    
    def check_if_ok(self, msg):
        print "Check if ok-function"
        sender = msg.sender
        receiver = msg.receiver
        type = msg.type
        subtype = msg.subtype
        data = msg.unpacked_data
        print "Data:", data
        if type == shared.data.MessageType.voip:
            if subtype == shared.data.VOIPType.response:
                print "voip response"
                self.out_dialog.destroy()
                self.show_voice(ip=data["ip"], port=data["port"])
            if subtype == shared.data.VOIPType.request:
                shared.util.set_color(0,0,255)
                print "voip request"
                self.inc_call_popup(msg)
        elif type == shared.data.MessageType.vvoip:
            if subtype == shared.data.VVOIPType.response:
                print "vvoip response"
                self.out_dialog.destroy()
                self.show_cam(ip=data["ip"], port1=data["port1"],
                              port2=data["port2"])
            elif subtype == shared.data.VVOIPType.request:
                shared.util.set_color(0,0,255)
                print "vvoip request"
                self.inc_call_popup(msg)
    
    def start_voip(self, msg):
        print "Staring voip"
        sender = msg.sender
        receiver = msg.receiver
        type = msg.type
        subtype = msg.subtype
        data = msg.unpacked_data
        message = shared.data.Message(self.controller.name, sender,
                                      type=shared.data.MessageType.voip, 
                                      subtype=shared.data.VOIPType.response,
                                      unpacked_data={"ip": get_ip(), "port": 5432, 
                                                     "class": "dict"},
                                      prio = 5)
        self.queue.enqueue(message.packed_data, message.prio)
        self.show_voice(ip=data["ip"], port=data["port"])
        
    def start_vvoip(self, msg):
        print "Staring vvoip"
        sender = msg.sender
        receiver = msg.receiver
        type = msg.type
        subtype = msg.subtype
        data = msg.unpacked_data
        message = shared.data.Message(self.controller.name, sender,
                                  type=shared.data.MessageType.vvoip, 
                                  subtype=shared.data.VVOIPType.response,
                                  unpacked_data={"ip": get_ip(), "port1": 5432,
                                                 "port2": 5434, "class": "dict"},
                                  prio = 5)
        self.queue.enqueue(message.packed_data, message.prio)
        self.show_cam(ip=data["ip"], port1=data["port1"], port2=data["port2"])
    
    def inc_call_popup(self, msg):
        sender = msg.sender
        print "Inkommande samtal = popup"
        inc_dialog = gtk.Dialog("Samtal",
                 self.window,  #the toplevel wgt of your app
                 gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,  #binary flags or'ed together
                 )
        who = gtk.Label(str(sender+" ringer..."))
        who.show()
        inc_dialog.set_size_request(400,200)
        #dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
        hang_up_button = gtk.Button("  Lägg på  ")
        inc_dialog.action_area.pack_start(hang_up_button)
        def hang_up(event):
            shared.util.set_color(0,0,0)
            # @todo: return nack if we dont want to answer
            print "upptaget"
            inc_dialog.destroy()
        hang_up_button.connect("clicked", hang_up)
        
        answer_button = gtk.Button("     Svara     ")
        inc_dialog.action_area.pack_start(answer_button)
        def answer(event):
            shared.util.set_color(0,0,0)
            if msg.type == shared.data.MessageType.voip:
                self.start_voip(msg)
                inc_dialog.destroy()
            elif msg.type == shared.data.MessageType.vvoip:
                self.start_vvoip(msg)
                inc_dialog.destroy()
        answer_button.connect("clicked", answer)
        
        inc_dialog.vbox.pack_start(who)
        question = gtk.Label("Vill du svara?")
        question.show()
        inc_dialog.vbox.pack_start(question)
        inc_dialog.show_all()
        
    def out_call_popup(self, msg):
        print "Utgående samtal = popup"
        if self.screens["contact"].name == None:
            return 0
        
        self.out_dialog = gtk.Dialog("Samtal",
                 self.window,  #the toplevel wgt of your app
                 gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,  #binary flags or'ed together
                 ("     Lägg på     ", 77))
        
        who = gtk.Label("Du ringer till "+self.screens["contact"].name)
        who.show()
        #dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
        self.out_dialog.vbox.pack_start(who)
        self.out_dialog.set_size_request(400,200)
        #dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
        self.out_dialog.show()
        result = self.out_dialog.run()
        if result == 77:
            if msg.type == shared.data.MessageType.voip:
                print "Lägger på"
            elif msg.type == shared.data.MessageType.vvoip:
                print "Lägger på"
        self.out_dialog.destroy()

    def start(self, event):
        # only do start method once
        self.db.disconnect(self.ready_handler_id)
        # start controller
        self.start_controller()
        self.message_dispatcher.process_items()
        # show gui
        self.window.show_all()
        self.show_default()
        # connect service level signal from controller
        self.controller.interface.connect_to_signal("signal_changed_service_level",
                                                    self.update_service_level)
        self.message_dispatcher.connect_to_type(shared.data.MessageType.vvoip,
                                                self.check_if_ok)
        self.message_dispatcher.connect_to_type(shared.data.MessageType.voip,
                                                self.check_if_ok)

    def run(self):
        '''
        Main GUI loop
        '''
        gobject.threads_init()
        self.ready_handler_id = self.db.connect("ready", self.start)
        self.db.ensure_ids()
        while self.mainloop.is_running():
            try:
                self.mainloop.run()
            except KeyboardInterrupt:
                self.mainloop.quit()

    def start_controller(self):
        '''
        Create and start ClientController
        '''
        # My initial status
        status = u"Available"
        self.controller = controller.ClientController(status, self.db)
        self.mapobjecthandler.controller = self.controller

    def update_service_level(self, service_level):
        self.screens["notifications"].update_label(service_level)
        unpacked_data = {"class": "dict", "service_level": service_level}
        if service_level == "ad-hoc" or service_level == "mega-low":
            pass
        else:
            msg = Message(self.controller.name, "server",
                          shared.data.MessageType.service_level,
                          unpacked_data = unpacked_data)
            self.queue.enqueue(msg.packed_data, msg.prio)

    def back_button_function(self, event):
        self.show(self.prev_page[-2])

    def ok_button_function(self, event):
        for screen in self.screens.values():
            if screen.props.visible and isinstance(screen, Screen):
                screen.ok_button_function(event)
                
    def no_button_function(self, event):
        for screen in self.screens.values():
            if screen.props.visible and isinstance(screen, Screen):
                screen.no_button_function(event)

    def change_button_function(self, event):
        for screen in self.screens.values():
            if screen.props.visible and isinstance(screen, Screen):
                screen.change_button_function(event)
        self.back_button_function(event)
                
    def delete_button_function(self, event):
        for screen in self.screens.values():
            if screen.props.visible and isinstance(screen, Screen):
                screen.delete_button_function(event)
        self.back_button_function(event)

    # mission view event handlers
    def show_mission(self, event):
        shared.util.set_color(0,0,0)
        self.mission_button.set_attention(False)
        self.toggle_show("mission", ["notifications", "map", "mission_menu"], 
                         "Här visas information relaterade till dina uppdrag")

    # mission buttons event handlers
    def show_mission_info(self, event):
        self.show(["info", "change_buttons"])
        missions = []
        for m in self.db.get_all_missions():
            for u in m.units:
                if u.name == config.client.name:
                    missions.append(m)
        self.screens["info"].set_missions(missions)

    def show_status(self, event):
        self.toggle_show("mission", ["notifications", "status", "buttons"], 
                         "Här kan du välj en status")

        combo = self.screens["status"].combo_box
        combo.get_model().clear()
        combo.append_text("Välj uppdrag...")
        combo.set_active(0)
        for mission in self.controller.missions:
            combo.append_text(mission.event_type)
    
    def show_journals(self, event):
        self.toggle_show("mission", ["notifications", "patient_journal", "pj_request_button_box"], 
                         "Här kan du hämta patient journaler")
    
    def show_faq(self, event):
        self.toggle_show("mission", ["notifications", "faq", "back_button_box"], 
                         "Här kan du få information om vanliga sjukdomar")
        
    # add object view event handlers
    def show_add_object(self, event):
        self.toggle_show("add_object", 
                         ["notifications", "map","add_object_menu"], 
                         "Välj en koordinat och sedan typ av objekt")
    
    # add object buttons event handlers
    def create_alarm(self, event):
        self.show(["alarm", "buttons"])
        self.screens["alarm"].coordx_entry.set_text(str(self.screens["map"].gps_x))
        self.screens["alarm"].coordy_entry.set_text(str(self.screens["map"].gps_y))
            
    def create_obstacle(self, event):
        self.show(["obstacle", "buttons"])
        self.screens["obstacle"].location_entry2.set_text(str(self.screens["map"].gps_x))
        self.screens["obstacle"].location_entry3.set_text(str(self.screens["map"].gps_y))
    
    def create_mission(self, event):
        self.show(["make_mission", "buttons"])
        self.screens["make_mission"].coordx_entry.set_text(str(self.screens["map"].gps_x))
        self.screens["make_mission"].coordy_entry.set_text(str(self.screens["map"].gps_y))

        combo = self.screens["make_mission"].combo_box
        combo.get_model().clear()
        combo.append_text("Välj larm...")
        combo.set_active(0)
        alarms = self.db.get_all_alarms()
        for alarm in alarms:
            combo.append_text(alarm.event)

    def create_new_message(self, event):
        self.toggle_show("messages", ["notifications", "new_message","buttons"], "Här kan du skriva ett nytt meddelanden")
        #self.show(["new_message", "buttons"])
        
    def show_cam(self,ip, port1, port2, event = None):
        self.screens["camera"].start_vvoip(ip, port1, port2)
        self.show(["camera"])
        
    def show_voice(self, ip, port, event = None):
        self.screens["camera"].start_voip(ip, port)
        self.show(["camera"])
        
    def show_outbox(self, event):
        self.toggle_show("messages", ["notifications", "output","back_button_box"], "Här visas dina utgångna meddelanden")
        #self.show(["output", "message_menu"])
       
        combo = self.screens["output"].combo_box
        combo.get_model().clear()
        combo.append_text("Välj textmeddelande...")
        combo.set_active(0)
         
        for textmessages in self.db.textmessages():
            list = []
            for unit in textmessages.units:
                list.append(unit)
            names = [u.name for u in list][:3]
            unitnames = ", ".join(names)
            if len(list) > 3:
                unitnames += "..."
            receiverandsubject = "Till: " + str(unitnames) + "    Ämne: " + str(textmessages.subject)
            
            if config.client.name == textmessages.sender:
                combo.append_text(receiverandsubject)
       
    def show_inbox(self, event):
        self.toggle_show("messages", ["notifications", "message","back_button_box"], "Här visas dina inkomna meddelanden")
        
        self.update_messagesbox(event)
        shared.util.set_color(0,0,0)
          
        self.messages_button.set_attention(False)
        label = self.messages_button.get_child()
        label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("black"))
        
    # contacts view event handlers
    def show_contacts(self,event):
        self.toggle_show("contacts", ["notifications","contact", "contact_menu"], "Här visas dina kontakter och du kan ringa till dem")
        screen = self.screens["contact"]
        screen.buttons = []
        for child in screen.vbox.get_children():
            screen.vbox.remove(child)
        for u in self.db.get_all_units():
            button = gtk.ToggleButton("%s" % u.name)
            button.show()
            screen.vbox.pack_start(button)
            button.connect("pressed", screen.select_contacts)
            screen.buttons.append(button)

    # messages view event handlers
    def show_messages(self, event):
        self.toggle_show("messages", ["notifications", "map","message_menu"], "Här kan du hantera dina meddelanden")
        
        self.update_messagesbox(event)
            
    def update_messagesbox(self, event):
        combo = self.screens["message"].combo_box
        combo.get_model().clear()
        combo.append_text("Välj textmeddelande...")
        combo.set_active(0)
        #self.db.units_in_text()
                  
        for textmessages in self.db.textmessages():
            #print textmessages.senderandsubject
            senderandsubject = "från: " + str(textmessages.sender) + "    Ämne: " + str(textmessages.subject)
            #textmessages.
            if config.client.name != textmessages.sender:
                combo.append_text(senderandsubject)
                
    def show_patient_journal_message(self, event):
        self.toggle_show("patient_journal_message", ["notifications", "patient_journal_message_screen","pj_button_box"], "Här visas dina meddelanden")
        
        self.screens["patient_journal_message_screen"].update_list()

    # show certain screen methods
    def toggle_show(self, button_key, screen_keys, notification_text = ""):
        '''
        Toggle clicked button, show specified screens and set notification.
        @param button_key: the key of the clicked button.
        @param screen_keys: the screens to show.
        @param notification_text: the notification text to set.
        '''
        if self.menu_buttons[button_key].get_active():
            for menu_button in self.menu_buttons.keys():
                if menu_button != button_key:
                    self.menu_buttons[menu_button].set_active(False)
            self.show(screen_keys)
            self.screens["notifications"].set_label(notification_text)
        else:
            self.show_default()
        if "add_object" in button_key and self.menu_buttons[button_key].get_active() == True:
            self.screens["map"].sign = True
            self.screens["map"].draw_sign()
        else:
            self.screens["map"].sign = False
            self.screens["map"].remove_sign()
    
    def show(self, keys):
        '''
        Show specified screens.
        @param keys: a list with keys to the screens to show. 
        '''
        self.prev_page.append(keys)

        for key in self.screens.keys():
            self.screens[key].hide_all()
        for key in keys:
            self.screens[key].show_all()
            
    def show_default(self):
        '''
        Show only default screens (GUI-background).
        '''
        for key in self.screens.keys():
            self.screens[key].hide_all()
        self.screens["notifications"].set_label("Team Med Fel")
        self.screens["notifications"].show_all()
        self.screens["map"].show()
        self.screens["map"].sign = False
        self.screens["map"].remove_sign()

    # handle key press events
    def on_key_press(self, widget, event, *args):
        # react on fullscreen button press
        if event.keyval == gtk.keysyms.F6:
            if self.window_in_fullscreen:
                self.window.unfullscreen()
            else:
                self.window.fullscreen()
        # Zoom out (-)
        if event.keyval == gtk.keysyms.F8:
            self.map.zoom("-")
        # Zoom in (+)
        elif event.keyval == gtk.keysyms.F7:
            self.map.zoom("+")  

    def on_window_state_change(self, widget, event, *args):
        if event.new_window_state & gtk.gdk.WINDOW_STATE_FULLSCREEN:
            self.window_in_fullscreen = True
        else:
            self.window_in_fullscreen = False