Python gi.repository.Gtk.main_quit() Examples

def main():
    """Run the module from the command line."""
    if len(sys.argv) <= 1 or len(sys.argv) > 5:
        print(_("Usage: {} text [title] [markup] [icon_name]").format(
            os.path.basename(__file__)), file=sys.stderr)
        exit(1)
    text = sys.argv[1]
    if len(sys.argv) > 2 and sys.argv[2]:
        title = sys.argv[2]
    else:
        title = "Epoptes"
    if len(sys.argv) > 3 and sys.argv[3]:
        markup = sys.argv[3].lower() == "true"
    else:
        markup = True
    if len(sys.argv) > 4:
        icon_name = sys.argv[4]
    else:
        icon_name = "dialog-information"

    window = MessageWindow(text, title, markup, icon_name)
    window.connect("destroy", Gtk.main_quit)
    window.show_all()
    Gtk.main() 

def on_exit(self, event=None, data=None):
        """Action call when the main programs is closed."""
        # cleanup temporary indicator icon
        os.remove(self.tindicator)
        # close the open dialogs
        if self._help_dialog is not None:
            self._help_dialog.destroy()

        if self._preferences_dialog is not None:
            self._preferences_dialog.destroy()

        logging.info("Terminated")
        self.alive.clear()  # DM: why bother with Event() ???

        try:
            Gtk.main_quit()
        except RuntimeError:
            pass 

def window_deleted_cb(self, widget, event, view):
        if (self._gui_config.get("confirm_close", self.DEFAULT_CONFIRM_CLOSE)
                and self._source_buffer.get_text(self._source_buffer.get_start_iter(),
                                                 self._source_buffer.get_end_iter(), True) != self.text):
            dlg = Gtk.MessageDialog(self._window, Gtk.DialogFlags.MODAL, Gtk.MessageType.QUESTION, Gtk.ButtonsType.NONE)
            dlg.set_markup(
                "<b>Do you want to close TexText without save?</b>\n\n"
                "Your changes will be lost if you don't save them."
            )
            dlg.add_button("Continue editing", Gtk.ResponseType.CLOSE) \
                .set_image(Gtk.Image.new_from_stock(Gtk.STOCK_GO_BACK, Gtk.IconSize.BUTTON))
            dlg.add_button("Close without save", Gtk.ResponseType.YES) \
                .set_image(Gtk.Image.new_from_stock(Gtk.STOCK_CLOSE, Gtk.IconSize.BUTTON))

            dlg.set_title("Close without save?")
            res = dlg.run()
            dlg.destroy()
            if res in (Gtk.ResponseType.CLOSE, Gtk.ResponseType.DELETE_EVENT):
                return True

        Gtk.main_quit()
        return False 

def quit(self):
        """Gracefully shut down application."""
        try:
            self._pa_mgr.close()
        except AttributeError:
            pass
        if Gtk.main_level() > 0:
            try:
                self._preferences.response(0)
            except AttributeError:
                pass
            try:
                self._about_win.close()
            except AttributeError:
                pass
            Gtk.main_quit()
        else:
            sys.exit(1) 

def _success_screen(self):
        self._win.remove_main_widget()
        title = _("Success")
        description = _("You're connected")
        buttons = [
            {
                'label': _("OK"),
                'type': 'KanoButton',
                'color': 'green',
                'callback': Gtk.main_quit
            }
        ]
        img_path = os.path.join(img_dir, "internet.png")

        self._win.set_main_widget(
            Template(
                title,
                description,
                buttons,
                self._win.is_plug(),
                img_path
            )
        ) 

def run(args):
    win = mainWindow(args)
    win.connect('delete-event', Gtk.main_quit)
    win.show_all()
    Gtk.main() 

def on_cancel_button_clicked(self, widget):
        self.accepted = False
        Gtk.main_quit() 

def on_cancelbutton_clicked(self, widget):
        Gtk.main_quit() 

def on_errordialog_close(self, widget):
        Gtk.main_quit() 

def on_menuitem_quit_activate(self, widget):
        """
        Triggered when the main window is closed from the menu. Terminates the
        Gtk main loop.
        """
        Gtk.main_quit() 

def onDestroy(self, *args):
        # On pressing close button
        Gtk.main_quit() 

def stop_manager(self, widget):
        Gtk.main_quit() 

def start(self):        
        self.connect("destroy", Gtk.main_quit)
        self.set_position(Gtk.WindowPosition.CENTER)
        self.show_all()
        GObject.threads_init()
        Gtk.main()
        return self.accepted 

def on_window1_destroy(self, widget):
        Gtk.main_quit() 

def register_view(self, view):
        """Called when the View was registered

        Can be used e.g. to connect signals. Here, the destroy signal is connected to close the application
        """
        super(SingleWidgetWindowController, self).register_view(view)
        self.shortcut_manager = ShortcutManager(self.view['main_window'])
        self.register_actions(self.shortcut_manager)

        view['main_window'].connect('destroy', Gtk.main_quit)
        # view.get_top_widget().connect('destroy', Gtk.main_quit) 

def __init__(self):
        Gtk.Window.__init__(self)
        self.box = Gtk.Box()
        self.add(self.box)

        colours = ["red", "blue", "green", "orange"]
        for c in colours:
            button = KanoButton("hello", color=c)
            self.box.pack_start(button, False, False, 0)
            button.connect("button-release-event", self.spinner_test)

        self.connect("delete-event", Gtk.main_quit)
        self.show_all() 

def stop_gtk():
    # shutdown twisted correctly
    if reactor_required():
        from twisted.internet import reactor
        if reactor.running:
            reactor.callFromThread(reactor.stop)
        # Twisted can be imported without the reactor being used
        # => check if GTK main loop is running
        elif Gtk.main_level() > 0:
            GLib.idle_add(Gtk.main_quit)
    else:
        GLib.idle_add(Gtk.main_quit)

    # Run the GTK loop until no more events are being generated and thus the GUI is fully destroyed
    wait_for_gui() 

def on_yes_button_clicked(self, widget):
        self.accepted = True
        Gtk.main_quit() 

def send_sms(recver, msg, ip, port, errordialog):
    HOST, PORT = ip, int(port)
    uuid = configmanager.uuid
    hostname = socket.gethostname()

    jsonobj = {'uuid': uuid, 'name': hostname, 
               'type': "sms", 'data': {'number': recver, 'message': msg}}

    data = json.dumps(jsonobj)

    # Initialize context
    ctx = SSL.Context(SSL.TLSv1_METHOD)
    ctx.set_options(SSL.OP_NO_SSLv2|SSL.OP_NO_SSLv3) #TLS1 and up
    ctx.set_verify(SSL.VERIFY_PEER, verify_cb) #Demand a certificate
    ctx.use_privatekey_file(configmanager.privatekeypath)
    ctx.use_certificate_file(configmanager.certificatepath)
    ctx.load_verify_locations(configmanager.cafilepath)                
    sslclientsocket = SSL.Connection(ctx, socket.socket(socket.AF_INET, socket.SOCK_STREAM))

    succ = False
    try:
        sslclientsocket.connect((HOST, PORT))
        sslclientsocket.sendall(data)
        sslclientsocket.recv(2)
        succ = True

    except Exception as e:
        errnum = e[0]
        print "Error " + str(e[0])
        if (errnum == -5):
            errordialog.format_secondary_text("The Device is not reachable. Maybe it's not on your Network")
        else:
            errordialog.format_secondary_text("Errornumber "+str(errnum))
        errordialog.run()
        errordialog.hide()

    finally:
        if (succ):
            sslclientsocket.shutdown()
            sslclientsocket.close()
            Gtk.main_quit() 

def on_errordialog_close(self, widget):
        Gtk.main_quit() 

def on_okbutton_clicked(self, widget):
        datadict = {}
        datadict['downloaddir'] = self.downloadfilechooserbutton.get_filename()
        datadict['bindip'] = self.ipentry.get_text()
        datadict['port'] = int(self.portentry.get_text())
        datadict['secure_port'] = int(self.secportentry.get_text())
        datadict['debug'] = False
        datadict['auto_open_urls'] = self.autourlswitch.get_active()
        datadict['auto_store_clipboard'] = self.autoclipboardswitch.get_active()
        datadict['auto_accept_files'] = self.autofileswitch.get_active()
        configmanager.write_config(datadict)
        restart_server()
        Gtk.main_quit() 

def on_closebutton_clicked(self, widget):
        Gtk.main_quit() 

def on_cancel_button_clicked(self, widget):
        self.accepted = False
        Gtk.main_quit() 

def on_yes_button_clicked(self, widget):
        self.accepted = True
        Gtk.main_quit() 

def start(self):        
        self.connect("destroy", Gtk.main_quit)
        self.set_position(Gtk.WindowPosition.CENTER)
        self.show_all()
        GObject.threads_init()
        Gtk.main()
        return self.accepted 

def open_folder(self, ac_name, args, a):
        Gtk.main_quit()
        self.callback("") 

def open_file(self, ac_name, filename, a):
        Gtk.main_quit()
        self.callback(a) 

def input_timeout(self):
        GObject.threads_init()
        timeout = FILE_TIMEOUT
        while self.waiting_for_user_input:
            time.sleep(1)
            timeout = timeout - 1
            if timeout == 0:
                self.file_notification.close()
                self.waiting_for_user_input = False
                buildNotification("File", "Filetranfser was canceled after 60 seconds")
                Gtk.main_quit()
                break 

def cancel(self, ac_name, args, a):
        self.waiting_for_user_input = False
        self.accepted = False
        Gtk.main_quit() 

def accept(self, ac_name, args, a):
        self.waiting_for_user_input = False
        self.accepted = True
        Gtk.main_quit()