from gajim.common.client import Client

 from gajim.common.helpers import make_http_request

 from gajim.common.helpers import get_random_string

 from gajim.common.storage.events import EventStorage

 from gajim.common.task_manager import TaskManager

 from gajim.common.settings import Settings

 from gajim.common.storage.draft import DraftStorage

 from gajim.common.storage.archive import MessageArchiveStorage

 class CoreApplication(ged.EventHelper):

     def __init__(self) -> None:

         for account in app.settings.get_active_accounts():

             app.connections[account] = Client(account)

         self.register_events([

             ('signed-in', ged.CORE, self._on_signed_in),

         ])

         if options.contains('warnings'):

             self._show_warnings()

     def start_profiling(self) -> None:

         self._log.info('Start profiling')

         self._profiling_session = cProfile.Profile()

         if client.get_module('MAM').available:

             client.get_module('MAM').request_archive_on_signin()

             return

         self.__options[1][optname] = value

     def get(self, optname=None):

         if not optname:

         opt[1][name] = {}

         for o in opt[0]:

             opt[1][name][o] = opt[0][o][Option.VAL]

     def del_per(self, typename, name, subname=None): # per_group_of_option

         if typename not in self.__options_per_key:

         # if subname is specified, delete the item in the group.

         elif subname in opt[1][name]:

             del opt[1][name][subname]

     def del_all_per(self, typename, subname):

         # Deletes all settings per typename

                 del opt[1][name][subname]

             except KeyError:

                 pass

     def set_per(self, optname, key, subname, value): # per_group_of_option

         if optname not in self.__options_per_key:

         if value is None:

             return

         obj[subname] = value

     def get_per(self, optname, key=None, subname=None, default=None): # per_group_of_option

         if optname not in self.__options_per_key:

         self.save_timeout_id = None

         return False

     def __init__(self):

         #init default values

         self._init_options()

             Gio.AppInfo.launch_default_for_uri(uri.data)

     elif uri.type == URIType.AT:

     elif uri.type == URIType.XMPP:

         if account is None:

                 'groupchat-join',

                 GLib.Variant('as', [account, jid]))

         elif uri.action == URIAction.MESSAGE:

         else:

             log.warning('Cant open URI: %s', uri)

         from gajim.gui.main import MainWindow

         MainWindow()

     def _open_uris(self, uris: list[str]) -> None:

         accounts = app.settings.get_active_accounts()

         if not accounts:

                     except Exception:

                         app.log('uri_handler').error('Invalid URI: %s', cmd)

     def _shutdown(self, _application: GajimApplication) -> None:

         self._shutdown_core()

                               _param: Optional[GLib.Variant]) -> None:

         accounts = app.settings.get_active_accounts()

         if len(accounts) == 1:

                 accounts[0], GAJIM_SUPPORT_JID)

             return

         open_window('StartChatDialog', initial_jid=GAJIM_SUPPORT_JID)

     def _on_open_chat_action(_action: Gio.SimpleAction,

                              param: GLib.Variant) -> None:

         account, jid = param.get_strv()

     @staticmethod

     @structs.actionfunction

         if not iter_:

             return

         service = model[iter_][0]

     def update_actions(self):

         if self.execute_button:

         if not iter_:

             return

         service = model[iter_][0]

     def update_actions(self):

         sens = \

     def _on_join(self, _button: Gtk.Button) -> None:

         nickname = self._nick_chooser.get_text()

             self.account, self._room_jid, nickname=nickname)

         self.destroy()

     def _on_join(self, _button: Gtk.Button) -> None:

         nickname = self._nick_chooser.get_text()

             self.account, self.jid, nickname=nickname)

         self.destroy()

         if control.get_autoscroll():

             self.mark_as_read(control.contact.account, control.contact.jid)

     @staticmethod

     def contact_info(account: str, jid: str) -> None:

         client = app.get_client(account)

         jid = self._muc_info_box.get_jid()

         nickname = self._nick_chooser.get_text()

         assert account

             account, str(jid), nickname=nickname)

         self.ready_to_destroy = True

     @staticmethod

     def _on_show(_widget: Gtk.MenuItem, show: str) -> None:

 class GtkStatusIcon(GtkMenuBackend):

     def _on_change_status(self, button: Gtk.Button) -> None:

         self._status_popover.popdown()

         new_status = button.get_name()

     def update(self) -> None:

         if self._account is None:

 from gajim.common import exceptions

 from gajim.common import proxy65_manager

 from gajim.common import socks5

 from gajim.common.events import FileCompleted

 from gajim.common.events import FileHashError

 from gajim.gui.file_transfer_send import SendFileDialog

 from gajim.gui.filetransfer import FileTransfersWindow

 from gajim.gui.control import ChatControl

 log = logging.getLogger('gajim.interface')

                 contact)

             SendFileDialog(contact, send_callback, app.window, [path])

     def process_connections(self) -> bool:

         '''

         Called each foo (200) milliseconds. Check for idlequeue timeouts

             raise

         return True  # renew timeout (loop for ever)

     def save_avatar(self, data: bytes) -> Optional[str]:

         return app.app.avatar_storage.save_avatar(data)

         return app.app.avatar_storage.get_avatar_path(filename) is not None

     def run(self, _application: Gtk.Application) -> None:

         # get instances for windows/dialogs that will show_all()/hide()

         self.instances['file_transfers'] = FileTransfersWindow()

         if sys.platform == 'win32':

             timeout, in_seconds = 20, None

         else:

         else:

             GLib.timeout_add(timeout, self.process_connections)

 class ThreadInterface:

     def __init__(self, func, func_args=(), callback=None, callback_args=()):