def setup_ui(self): """ Sets up the UI. Loads all files necessary to set up the individual Views For Testing purposes Only: Pops up the warning window, when the UI is started. """ self.builderMainWin = gtk.Builder() self.builderConfWin = gtk.Builder() self.builderMainWin.add_from_file(find("Projekt_DebugUI_MainWindow.glade")) self.builderConfWin.add_from_file(find("Projekt_DebugUI_Confirmation.glade")) # die externe Nachrichtensicht self.builderNewsExt = gtk.Builder() self.builderNewsExt.add_from_file(find("Projekt_DebugUI_NewsExt.glade")) # die externe Roboauswahlsicht self.builderRoboSel = gtk.Builder() self.builderRoboSel.add_from_file(find("Projekt_DebugUI_RoboSelect.glade")) # das Aboutfenster self.builderAboutView = gtk.Builder() self.builderAboutView.add_from_file(find("Projekt_DebugUI_Aboutfenster2.glade")) self.aboutD = self.builderAboutView.get_object("Aboutfenster") ##die externe Kamerasicht # self.builderCameraView = gtk.Builder() # self.builderCameraView.add_from_file(find("debug-ui-neu/Projekt_DebugUI_CameraView.glade")) self.mainwindow = self.builderMainWin.get_object("mainWindowDebugUI") self.confWin = self.builderConfWin.get_object("messagedialogQuitConf") # Views anzeigen # TODO: das will vielleicht dynamischer werden self.builderMainWin.get_object("Content1").add(self.views[0]) self.builderMainWin.get_object("Content3").add(self.views[1]) self.builderMainWin.get_object("Content2").add(self.views[2]) self.viewslots_oben = [] self.viewslots_unten = [] self.viewslots_oben.append(self.builderMainWin.get_object("Content1")) self.viewslots_oben.append(self.builderMainWin.get_object("Content2")) self.viewslots_unten.append(self.builderMainWin.get_object("Content3")) self.mainwindow.show_all() # self.imageViewFrame = self.builderMainWin.get_object("frameImageview") # self.imageFrame1 = self.builderMainWin.get_object("frame1") # fenster für values anlegen, aber nicht zeigen self.RoboSel = self.builderRoboSel.get_object("RoboSelectExtern") self.builderRoboSel.connect_signals(self) # fenster für externe LogView self.NewsExt = self.builderNewsExt.get_object("NewsExtern") self.builderNewsExt.connect_signals(self) # self.make_view(name, imageViewFrame) # self.me_show.show() # self.store = DataStore() self.debug_plain_dumper = DebugPlainDumper() # Automatische Verbindung der in Glade festgelegten Signals mit ihren Handlern. self.builderMainWin.connect_signals(self) self.builderConfWin.connect_signals(self) self.builderAboutView.connect_signals(self)
class DebugUiMainWin(object): """ The Main Class of the UI, which contains most functionalities of the UI itself, as well as some of the more basic views. """ def __init__(self, server): """ Initializes the mainwindow and, by doing that, the UI itself. Sets up the views and provides them with the Datastream from the robots. :param server: The Server, from which the data is put into the UI :type server: A Datastream (Not entirely sure about that. More Information is required!) """ self.store = DataStore() self.views = [] # wir fügen erstmal statisch 3 Views hinzu # TODO: dynamisch & config self.views.append(MotorView(self.store.add_observer, self.view_calback)) if config["NeedVisionView"]: self.views.append(VisionView(self.store.add_observer, self.view_calback)) else: self.views.append(WorldView(self.store.add_observer, self.view_calback)) self.views.append(HalfFieldView(self.store.add_observer, self.view_calback)) print self.views self.setup_ui() self.robots = [] self.treestores = {} self.backlog = [] self.last_log_message = None self.last_log_message_count = None server.add_listener(self.on_debug_message) gobject.timeout_add(100, self.handle_backlog) self.last_image = None self.last_shapes = None self.last_width = self.last_height = None def setup_ui(self): """ Sets up the UI. Loads all files necessary to set up the individual Views For Testing purposes Only: Pops up the warning window, when the UI is started. """ self.builderMainWin = gtk.Builder() self.builderConfWin = gtk.Builder() self.builderMainWin.add_from_file(find("Projekt_DebugUI_MainWindow.glade")) self.builderConfWin.add_from_file(find("Projekt_DebugUI_Confirmation.glade")) # die externe Nachrichtensicht self.builderNewsExt = gtk.Builder() self.builderNewsExt.add_from_file(find("Projekt_DebugUI_NewsExt.glade")) # die externe Roboauswahlsicht self.builderRoboSel = gtk.Builder() self.builderRoboSel.add_from_file(find("Projekt_DebugUI_RoboSelect.glade")) # das Aboutfenster self.builderAboutView = gtk.Builder() self.builderAboutView.add_from_file(find("Projekt_DebugUI_Aboutfenster2.glade")) self.aboutD = self.builderAboutView.get_object("Aboutfenster") ##die externe Kamerasicht # self.builderCameraView = gtk.Builder() # self.builderCameraView.add_from_file(find("debug-ui-neu/Projekt_DebugUI_CameraView.glade")) self.mainwindow = self.builderMainWin.get_object("mainWindowDebugUI") self.confWin = self.builderConfWin.get_object("messagedialogQuitConf") # Views anzeigen # TODO: das will vielleicht dynamischer werden self.builderMainWin.get_object("Content1").add(self.views[0]) self.builderMainWin.get_object("Content3").add(self.views[1]) self.builderMainWin.get_object("Content2").add(self.views[2]) self.viewslots_oben = [] self.viewslots_unten = [] self.viewslots_oben.append(self.builderMainWin.get_object("Content1")) self.viewslots_oben.append(self.builderMainWin.get_object("Content2")) self.viewslots_unten.append(self.builderMainWin.get_object("Content3")) self.mainwindow.show_all() # self.imageViewFrame = self.builderMainWin.get_object("frameImageview") # self.imageFrame1 = self.builderMainWin.get_object("frame1") # fenster für values anlegen, aber nicht zeigen self.RoboSel = self.builderRoboSel.get_object("RoboSelectExtern") self.builderRoboSel.connect_signals(self) # fenster für externe LogView self.NewsExt = self.builderNewsExt.get_object("NewsExtern") self.builderNewsExt.connect_signals(self) # self.make_view(name, imageViewFrame) # self.me_show.show() # self.store = DataStore() self.debug_plain_dumper = DebugPlainDumper() # Automatische Verbindung der in Glade festgelegten Signals mit ihren Handlern. self.builderMainWin.connect_signals(self) self.builderConfWin.connect_signals(self) self.builderAboutView.connect_signals(self) # --------------- Eventhandler Implementationen ------------------------------- def show(self): self.mainwindow.show() def gtk_main_quit(self, *args): gtk.main_quit() print ("Die komplette Anwendung wurde geschlossen") def view_calback(self, art, view): if art == "add": print "Add new Window" self.views.append(view) self.show_views() else: print "UNSUPORTED view-calback type: %s" % art def show_views(self): content_count = len(self.viewslots_oben) + len(self.viewslots_unten) print "Contentcount, views ", content_count, len(self.views) if len(self.views) > content_count: content_object = self.viewslots_oben.pop() child = content_object.get_child() hpaned = gtk.HPaned() contend_holder1 = gtk.Alignment() hpaned.add1(contend_holder1) contend_holder2 = gtk.Alignment() hpaned.add2(contend_holder2) child.reparent(contend_holder1) # TODO: absicherung, das das neue nicht am ende steht contend_holder2.add(self.views[-1]) content_object.add(hpaned) content_object.show_all() self.viewslots_oben.append(contend_holder1) self.viewslots_oben.append(contend_holder2) def handle_log_messages(self, logs): """ Displays the log messages from the robots in the log view :param logs: The Messages to be displayed :type logs: A list of log messages """ model = self.builderMainWin.get_object("logmodel") model2 = self.builderMainWin.get_object("logmodel2") # fürs warnnachrichtenfenster # dazugekommen für externes NachrichtenFenster # print ("hole die logmodels des externen Nachrichtenfensters") model3 = self.builderNewsExt.get_object("logmodel") model4 = self.builderNewsExt.get_object("logmodel2") # fürs externe warnnachrichtenfenster # Kommi von Robocuppern: Merken, ob die letzte Zeile markiert ist # von uns dazugekommen:------------------- logview = self.builderMainWin.get_object("logview") # print("hole den logview des externen Nachrichtenfensters") logview3 = self.builderNewsExt.get_object("logview") path, _ = logview.get_cursor() externpath, _ = logview3.get_cursor() # scrollWin = self.builderMainWin.get_object("nachrichtenScrolledwindow") # nachrVerlaufscroll = self.builderMainWin.get_object("checkmenuitemNachrichten") # warnVerlaufscroll = self.builderMainWin.get_object("checkmenuitemNachrichten2") # fragt ab ob die Menüpunkte "Nachrichten mitscrollen" und "Warnungen mitscrollen" aktiviert sind # scroll_to_end = nachrVerlaufscroll.get_active() # scroll_to_end2 = warnVerlaufscroll.get_active() # scroll_to_end = scrollWin.autoscroll.get_active() funzt leider auch net. # Nils fragen. for item in logs: # Wird aufgerufen, wenn eine LogNachricht verarbeitet werden soll # Zeile fuer die UI fertig machen if item.type == "warning": newrow = ("<span foreground='red'>" + item.name[:-8] + "</span>", item.value) else: newrow = (item.name[:-4], item.value) if self.last_log_message == newrow: # Letzte Zeile einfach updaten self.last_log_message_count += 1 model[-1][1] = "%s (%d mal)" % (item.value, self.last_log_message_count) # dazugekommen fürs externe nachrichtenfenster model3[-1][1] = "%s (%d mal)" % (item.value, self.last_log_message_count) if item.type == "warning": model2[-1][1] = "%s (%d mal)" % (item.value, self.last_log_message_count) model4[-1][1] = "%s (%d mal)" % (item.value, self.last_log_message_count) continue self.last_log_message = newrow self.last_log_message_count = 1 model.append(newrow) model3.append(newrow) # dazugekommen if item.type == "warning": model2.append(newrow) model4.append(newrow) # muss spaeter einkommentiert werden wenn autoscroll s.o. funzt. # if scroll_to_end and row is not None: # path = model.get_string_from_iter(row) # logview.set_cursor(path) # path = self.mainwindow.logmodel.get_string_from_iter(row) # self.mainwindow.logview.set_cursor(path) # erstellt die Roboansicht mit der benötigten Anzahl an Tabs, mit dem Robonamen darin und den zugehörigen Treeviews def make_new_value_tab(self, store, notebook, robot): """ Creates the tabbed robotview with the right number of tabs and the respective names of the robots as the title of the tab. :param store: :type store: :param notebook: :type notebook: :param robot: :type robot: """ view = gtk.TreeView(store) lable = gtk.Label(robot) colm1 = gtk.TreeViewColumn("Name", gtk.CellRendererText(), text=3) colm1.set_resizable(True) colm1.set_sizing(True) view.insert_column(colm1, -1) colm2 = gtk.TreeViewColumn("Type", gtk.CellRendererText(), text=1) colm2.set_resizable(True) colm2.set_sizing(True) view.insert_column(colm2, -1) colm3 = gtk.TreeViewColumn("Object", gtk.CellRendererText(), text=2) colm3.set_resizable(True) colm3.set_sizing(True) view.insert_column(colm3, -1) scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scroll.add(view) notebook.insert_page(scroll, lable, -1) # macht den treeview wieder anklickbar view.connect("button-release-event", self.on_treeview_clicked) def handle_backlog(self): """ Handles the backlog (Needs to be expanded upon). """ # print("handle_backlog wurde aufgerufen") #merke: wird immer nach handle_log_messages aufgerufen done = set() todo = [] logs = [] for item in reversed(self.backlog): if item.type in ["log", "warning"]: logs.append(item) continue if item.name in done: continue done.add(item.name) todo.append(item) self.backlog = [] self.handle_log_messages(reversed(logs)) # items fürs werdeview for item in reversed(todo): # wir trennen den namen des roboters ab robot, name = item.name.split("::") # hostname einklappbar? # name = item.name.replace('::','.') # different robots go to different views if robot not in self.robots: # wenn wir den Roboter noch nicht hatten legen wir ihn an self.robots.append(robot) notebook = self.builderMainWin.get_object("roboNotebook") notebook_extern_window = self.builderRoboSel.get_object("roboNotebook") store = gtk.TreeStore( gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING ) self.treestores[robot] = store self.make_new_value_tab(store, notebook, robot) self.make_new_value_tab(store, notebook_extern_window, robot) # fenster neu zeichnen sonst ists nicht sichtbar!!! self.mainwindow.show_all() # das sorgt fürs sofortige auftauchen daher noch auskommentiert # self.builderRoboSel.get_object("RoboSelectExtern").show_all() # TODO: bessere Stelle dafür finden # allen Views vom neuen Roboter erzählen print "Bla: ", self.views for view in self.views: view.add_new_robot(robot) print "called new_robot on ", view model = self.treestores[robot] # find existing part of the path: names = name.rsplit(".") names.reverse() # make popping easier # obtain the TreeStore root element treeit = model.get_iter_first() path_prefix = treeit oldit = path_prefix name = names.pop() matched_something = False # Extend existing paths as long as possible while treeit is not None and len(names) > 0: # this entry can be extended if model.get_value(treeit, 3) == name: matched_something = True name = names.pop() oldit = treeit # oldit2 = treeit2 #-.- treeit = model.iter_children(treeit) # try next iterator else: treeit = model.iter_next(treeit) # generate rest part of path new if not matched_something: oldit = None while len(names) > 0: newit = model.iter_children(oldit) # Find first lexical higher sibling while newit is not None: if model.get_value(newit, 3) > name: break newit = model.iter_next(newit) # insert before the first lexical higher sibling # no problem if newit is none it will be appended to oldit instead oldit = model.insert_before(oldit, newit, (item.name, "", "", name)) name = names.pop() # last node reached generate_last = True if len(names) == 0: # See if exact match is possible while treeit is not None: if model.get_value(treeit, 3) == name: model.set(treeit, 0, item.name, 1, item.type, 2, format(item), 3, name) generate_last = False break # lexically higher value means break too if model.get_value(treeit, 3) > name: break treeit = model.iter_next(treeit) # No last match possible, make new if generate_last: # If treeit is None it will be appended to oldit oldit = model.insert_before(oldit, treeit, (item.name, item.type, format(item), name)) self.store.update(item) assert len(names) == 0 return True def on_debug_message(self, type, name, value): """ Verarbeitet Debug-Nachrichten """ self.debug_plain_dumper.dump(type, name, value) if type == "shape": return # Item erzeugen item = DataItem(name, type, value) self.backlog.append(item) # Methode angepasst. Bewirkt das der Nachrichtenfilter funktioniert def on_filter_changed(self, widget): """ Wird von der UI aufgerufen, wenn der Text im Nachrichtenfilter veraendert wird. Setzt ein neues Filter-Modell in dem TreeView """ logmodel = self.builderMainWin.get_object("logmodel") logview = self.builderMainWin.get_object("logview") # logmodel und logview des externen Nachrichtenfensters logmodel2 = self.builderNewsExt.get_object("logmodel") logview2 = self.builderNewsExt.get_object("logview") text = widget.get_text().strip() if not text: # keine Filterung logview.set_model(logmodel) logview2.set_model(logmodel2) return # Filter aktivieren model = logmodel.filter_new() model2 = logmodel2.filter_new() func = lambda model, it: (model.get_value(it, 0) or "").find(text) != -1 func2 = lambda model2, it: (model2.get_value(it, 0) or "").find(text) != -1 model.set_visible_func(func) model2.set_visible_func(func2) logview.set_model(model) logview2.set_model(model2) # dazugekommene Methode, damit der Warnungsfilter auch funktioniert. def on_filter_changed2(self, widget): """ Wird von der UI aufgerufen, wenn der Text im Warnungsfilter veraendert wird. Setzt ein neues Filter-Modell in dem TreeView """ logmodel3 = self.builderMainWin.get_object("logmodel2") logview3 = self.builderMainWin.get_object("logview2") # logmodel und logview des externen Warnungsfensters logmodel4 = self.builderNewsExt.get_object("logmodel2") logview4 = self.builderNewsExt.get_object("logview2") text = widget.get_text().strip() if not text: # keine Filterung logview3.set_model(logmodel3) logview4.set_model(logmodel4) return # Filter aktivieren model3 = logmodel3.filter_new() model4 = logmodel4.filter_new() func = lambda model3, it: (model3.get_value(it, 0) or "").find(text) != -1 func2 = lambda model4, it: (model4.get_value(it, 0) or "").find(text) != -1 model3.set_visible_func(func) model4.set_visible_func(func2) logview3.set_model(model3) logview4.set_model(model4) def on_treeview_clicked(self, treeview, event): print ("on_treeview_clicked wurde aufgerufen!") if event.button != 3: return # Gucken worauf wir geklickt haben x, y = int(event.x), int(event.y) path = treeview.get_path_at_pos(x, y) if path is None: return # Zeile holen, die wir angeklickt haben model = treeview.get_model() name, dtype = model.get(model.get_iter(path[0]), 0, 1) print name, dtype menu = gtk.Menu() me_expand = gtk.MenuItem("Expand All") me_expand.connect("activate", lambda mi: treeview.expand_row(path[0], True)) menu.append(me_expand) me_collapse = gtk.MenuItem("Collapse All") me_collapse.connect("activate", lambda mi: treeview.collapse_row(path[0])) menu.append(me_collapse) if dtype == "matrix": global ImageViewUnser self.ImageView = self.builderMainWin.get_object("frameImageview") me_show = gtk.MenuItem("Show Image") me_show.connect("activate", lambda mi: self.make_view(name, self.ImageView)) menu.append(me_show) elif dtype == "string" and "Dot" in name: me_show = gtk.MenuItem("Graph anzeigen") me_show.connect("activate", lambda mi: self.make_view(name, DotView)) menu.append(me_show) elif dtype == "number": plot = gtk.MenuItem("Plot") plot.connect("activate", lambda mi: self.plot_numbers(name)) menu.append(plot) # Menu oeffnen treeview.grab_focus() treeview.set_cursor(path[0]) menu.show_all() menu.popup(None, None, None, event.button, event.time) def plot_numbers(self, name): """Plotet den key mit matpotlib""" data = [[], []] self.store.add_observer(name, lambda item: self.update_plot(item, data)) graphThread = MotorTempGraph(data, name, None) graphThread.start() def update_plot(self, item, data): """Updates plotdata""" data[1].append(item.value) data[0].append(time.time()) # TODO: # Es passiert noch nix, beim Klicken auf die Menüpunkte. die GenericView müsste # glaube ich angesprochen werden und dann die entsprechende View im Uebersichtsfenster hinzufügen. def make_view(self, name, clazz, **kwargs): """ Creates a generic view from a specified clazz. :param name: The name that shall be registered as an observer. :type name: String :param clazz: A Frame, from which the generic view is created. :type clazz: Frame """ cleanup_ops = [] def destroy(): view.cleanup() self.views.remove(view) self.store.del_observer(None, view.update) for op in cleanup_ops: op() def add_observer(name, func): self.store.add_observer(name, func) cleanup_ops.append(lambda: self.store.del_observer(name, func)) # View erzeugen view = clazz(destroy, **kwargs) view.update(self.store.get(name)) view.register_observers(name, add_observer) self.store.add_observer(name, view.update) self.views.append(view) def on_nachrichtenButtonEigenesFenster_clicked(self, *args): """ Makes the extended log view visible. """ print ("Externes Fenster fuer Nachrichten wurde erstellt") self.NewsExt.show() def open_confirmationwin(self, *args): """ Opens the confirmation window on clicking one of the 'quit'-buttons. """ self.confWin.show() return True def on_messagedialogQuitConf_delete(self, *args): """ Closes the confirmation window on positive confirmation. """ self.confWin.hide() return True # Signal wurde vollständig bearbeitet def on_buttonConfN_clicked(self, *args): """ Closes the confirmation window on negative confirmation. """ self.confWin.hide() return True # Signal wurde vollständig bearbeitet # ------------------------------------------------------------------------------ # Diese folgenden Handler werden zZ. nicht benötigt, können aber später verwendet werden, falls die Debug-UI um # die Optionen "Ansicht speichern" usw. in der Menüleiste, erweitert werden möchte. Gladedateien vorhanden. def on_imageMenuItemOeffnen_activate(self, *args): """ Opens the 'Open'-filechooser. """ self.builderFilChoOp = gtk.Builder() self.builderFilChoOp.add_from_file(find("Projekt_DebugUI_FilechooserOeffnen.glade")) self.filChoOp = self.builderFilChoOp.get_object("filechooserdialogOeffnen") self.builderFilChoOp.connect_signals(self) print ("Oeffnen-Filechooser wurde erstellt") self.filChoOp.show() def on_imageMenuItemSpeichernUnter_activate(self, *args): """ Opens the 'Save as'-filechooser. """ self.builderFilChoSav = gtk.Builder() self.builderFilChoSav.add_from_file(find("Projekt_DebugUI_FilechooserSpeichernUnter.glade")) self.filChoSav = self.builderFilChoSav.get_object("filechooserdialogSpeichernUnter") self.builderFilChoSav.connect_signals(self) print ("SpeichernUnter-Filechooser wurde erstellt") self.filChoSav.show() def on_imageMenuItemPreferences_activate(self, *args): """ Opens the window for changing preferences. """ self.builderPref = gtk.Builder() self.builderPref.add_from_file(find("Projekt_DebugUI_Einstellungenfenster.glade")) self.Pref = self.builderPref.get_object("windowEinstellungen") self.builderPref.connect_signals(self) print ("Preferences-Fenster wurde erstellt") self.Pref.show() def on_filechooserdialogSpeichernUnter_destroy(self, *args): """ Closes the 'Save as' filechooser. """ self.filChoSav.destroy() print ("SpeichernUnter-Filechooser wurde geschlossen") return True # Signal wurde vollständig bearbeitet def on_filechooserdialogOeffnen_destroy(self, *args): """ Closes the Filechooser for opening files. """ self.filChoOp.destroy() print ("Oeffnen-Filechooser wurde geschlossen") return True # Signal wurde vollständig bearbeitet def on_windowEinstellungen_destroy(self, *args): """ Closes the preferences window """ self.Pref.destroy() print ("Einstellungenfenster wurde geschlossen") return True # Signal wurde vollständig bearbeitet # ------------------------------------------------------------------------------ def on_roboButtonEigenesFenster_clicked(self, *args): """ Opens the robot selection in a seperate window. """ print ("Externes Fenster fuer Roboterauswahl wurde erstellt") self.RoboSel.show_all() def on_RoboSelectExtern_destroy(self, *args): """ Closes the seperate robot selection window. """ self.RoboSel.hide() print ("externes Robofenster geschlossen bzw versteckt") return True # Verhindern der Zerstörung des Fenseters (angeblich) def on_delete_extern_log_view(self, *donotcare): """ Closes the seperate log view. """ self.NewsExt.hide() # Fenster verstecken print "externe log view verstecken" return True # Signal nicht weiter verarbeiten def on_uebersichtButtonMax_clicked(self, *args): """ Maximizes the Overview within the main window and changes the button to be able do de-maximize it. """ print "Die Zähmung des Widerspenstigen Buttons" self.uebersichtBttnMax = self.builderMainWin.get_object("uebersichtButtonMax") self.hPane = self.builderMainWin.get_object("hpaned1") if self.uebersichtBttnMax.get_stock_id() == "gtk-fullscreen": print "Wenn Button fullscreenbild hat dann aender ihn zu +kleiner machen+" self.uebersichtBttnMax.set_stock_id("gtk-leave-fullscreen") self.hPane.set_position(0) else: print "Wenn Button +wiedern kleiner machen+ dann aender ihn zu fullscreen" self.uebersichtBttnMax.set_stock_id("gtk-fullscreen") self.hPane.set_position(300) def on_roboButtonMax_clicked(self, *args): self.roboBttnMax = self.builderMainWin.get_object("roboButtonMax") self.uebersicht = self.builderMainWin.get_object("uebersichtsFrame") self.nachrichtExp = self.builderMainWin.get_object("NachrichtenverlaufExpander") self.vPane1 = self.builderMainWin.get_object("vpaned1") if self.roboBttnMax.get_stock_id() == "gtk-fullscreen": print "Wenn Button fullscreenbild hat dann aender ihn zu +kleiner machen+" self.roboBttnMax.set_stock_id("gtk-leave-fullscreen") self.uebersicht.hide() self.nachrichtExp.set_expanded(False) self.vPane1.set_position(925) else: print "Wenn Button +wiedern kleiner machen+ dann aender ihn zu fullscreen" self.roboBttnMax.set_stock_id("gtk-fullscreen") self.uebersicht.show() self.nachrichtExp.set_expanded(True) self.vPane1.set_position(280) def on_nachrichtenButtonMax_clicked(self, *args): """ Maximizes the log and changes the button, allowing to restore it to normal size. """ print ("maximiere das Nachrichtenfenster") self.nachrichtBttnMax = self.builderMainWin.get_object("nachrichtenButtonMax") self.uebersicht = self.builderMainWin.get_object("uebersichtsFrame") self.roboAuswExp = self.builderMainWin.get_object("RoboauswahlExpander") self.vPane1 = self.builderMainWin.get_object("vpaned1") if self.nachrichtBttnMax.get_stock_id() == "gtk-fullscreen": print "Wenn Button fullscreenbild hat dann aender ihn zu +kleiner machen+" self.nachrichtBttnMax.set_stock_id("gtk-leave-fullscreen") self.uebersicht.hide() self.roboAuswExp.set_expanded(False) self.vPane1.set_position(0) else: print "Wenn Button +wiedern kleiner machen+ dann aender ihn zu fullscreen" self.nachrichtBttnMax.set_stock_id("gtk-fullscreen") self.uebersicht.show() self.roboAuswExp.set_expanded(True) self.vPane1.set_position(280) def on_imagemenuitemAbout_activate(self, *args): print ("öffne das Aboutfenster") """ Opens the 'About'-window. """ print ("öffne das Aboutfenster") self.aboutD.show() def on_buttonAboutfensterSchliessen_clicked(self, *args): """ Closes the 'About'-window. """ print ("schließe das Aboutfenster") self.aboutD.hide() return True # gtk mitteilen das signal bearbeitet wurde