--- a/sat_frontends/primitivus/base.py	Fri Apr 07 15:18:39 2023 +0200
+++ b/sat_frontends/primitivus/base.py	Sat Apr 08 13:54:42 2023 +0200
@@ -20,7 +20,7 @@
 from sat.core.i18n import _, D_
 from sat_frontends.primitivus.constants import Const as C
 from sat.core import log_config
-log_config.satConfigure(C.LOG_BACKEND_STANDARD, C)
+log_config.sat_configure(C.LOG_BACKEND_STANDARD, C)
 from sat.core import log as logging
 log = logging.getLogger(__name__)
 from sat.tools import config as sat_config
@@ -45,8 +45,8 @@
 import sys
 ## bridge handling
 # we get bridge name from conf and initialise the right class accordingly
-main_config = sat_config.parseMainConf()
-bridge_name = sat_config.getConfig(main_config, '', 'bridge', 'dbus')
+main_config = sat_config.parse_main_conf()
+bridge_name = sat_config.config_get(main_config, '', 'bridge', 'dbus')
 if 'dbus' not in bridge_name:
     print(u"only D-Bus bridge is currently supported")
     sys.exit(3)
@@ -63,8 +63,8 @@
                  a_key['MODE_COMMAND']: (C.MODE_COMMAND, u':')} #XXX: captions *MUST* be unicode
         super(EditBar, self).__init__(modes)
         self.host = host
-        self.setCompletionMethod(self._text_completion)
-        urwid.connect_signal(self, 'click', self.onTextEntered)
+        self.set_completion_method(self._text_completion)
+        urwid.connect_signal(self, 'click', self.on_text_entered)
 
     def _text_completion(self, text, completion_data, mode):
         if mode == C.MODE_INSERTION:
@@ -78,47 +78,47 @@
         else:
             return text
 
-    def onTextEntered(self, editBar):
+    def on_text_entered(self, editBar):
         """Called when text is entered in the main edit bar"""
         if self.mode == C.MODE_INSERTION:
             if isinstance(self.host.selected_widget, quick_chat.QuickChat):
                 chat_widget = self.host.selected_widget
-                self.host.messageSend(
+                self.host.message_send(
                     chat_widget.target,
                     {'': editBar.get_edit_text()}, # TODO: handle language
                     mess_type = C.MESS_TYPE_GROUPCHAT if chat_widget.type == C.CHAT_GROUP else C.MESS_TYPE_CHAT, # TODO: put this in QuickChat
-                    errback=lambda failure: self.host.showDialog(_("Error while sending message ({})").format(failure), type="error"),
+                    errback=lambda failure: self.host.show_dialog(_("Error while sending message ({})").format(failure), type="error"),
                     profile_key=chat_widget.profile
                     )
                 editBar.set_edit_text('')
         elif self.mode == C.MODE_COMMAND:
-            self.commandHandler()
+            self.command_handler()
 
-    def commandHandler(self):
+    def command_handler(self):
         #TODO: separate class with auto documentation (with introspection)
         #      and completion method
         tokens = self.get_edit_text().split(' ')
         command, args = tokens[0], tokens[1:]
         if command == 'quit':
-            self.host.onExit()
+            self.host.on_exit()
             raise urwid.ExitMainLoop()
         elif command == 'messages':
-            wid = sat_widgets.GenericList(logging.memoryGet())
-            self.host.selectWidget(wid)
+            wid = sat_widgets.GenericList(logging.memory_get())
+            self.host.select_widget(wid)
         # FIXME: reactivate the command
         # elif command == 'presence':
         #     values = [value for value in commonConst.PRESENCE.keys()]
         #     values = [value if value else 'online' for value in values]  # the empty value actually means 'online'
         #     if args and args[0] in values:
         #         presence = '' if args[0] == 'online' else args[0]
-        #         self.host.status_bar.onChange(user_data=sat_widgets.ClickableText(commonConst.PRESENCE[presence]))
+        #         self.host.status_bar.on_change(user_data=sat_widgets.ClickableText(commonConst.PRESENCE[presence]))
         #     else:
-        #         self.host.status_bar.onPresenceClick()
+        #         self.host.status_bar.on_presence_click()
         # elif command == 'status':
         #     if args:
-        #         self.host.status_bar.onChange(user_data=sat_widgets.AdvancedEdit(args[0]))
+        #         self.host.status_bar.on_change(user_data=sat_widgets.AdvancedEdit(args[0]))
         #     else:
-        #         self.host.status_bar.onStatusClick()
+        #         self.host.status_bar.on_status_click()
         elif command == 'history':
             widget = self.host.selected_widget
             if isinstance(widget, quick_chat.QuickChat):
@@ -126,22 +126,22 @@
                     limit = int(args[0])
                 except (IndexError, ValueError):
                     limit = 50
-                widget.updateHistory(size=limit, profile=widget.profile)
+                widget.update_history(size=limit, profile=widget.profile)
         elif command == 'search':
             widget = self.host.selected_widget
             if isinstance(widget, quick_chat.QuickChat):
                 pattern = " ".join(args)
                 if not pattern:
-                    self.host.notif_bar.addMessage(D_("Please specify the globbing pattern to search for"))
+                    self.host.notif_bar.add_message(D_("Please specify the globbing pattern to search for"))
                 else:
-                    widget.updateHistory(size=C.HISTORY_LIMIT_NONE, filters={'search': pattern}, profile=widget.profile)
+                    widget.update_history(size=C.HISTORY_LIMIT_NONE, filters={'search': pattern}, profile=widget.profile)
         elif command == 'filter':
             # FIXME: filter is now only for current widget,
             #        need to be able to set it globally or per widget
             widget = self.host.selected_widget
             # FIXME: Q&D way, need to be more generic
             if isinstance(widget, quick_chat.QuickChat):
-                widget.setFilter(args)
+                widget.set_filter(args)
         elif command in ('topic', 'suject', 'title'):
             try:
                 new_title = args[0].strip()
@@ -149,12 +149,12 @@
                 new_title = None
             widget = self.host.selected_widget
             if isinstance(widget, quick_chat.QuickChat) and widget.type == C.CHAT_GROUP:
-                widget.onSubjectDialog(new_title)
+                widget.on_subject_dialog(new_title)
         else:
             return
         self.set_edit_text('')
 
-    def _historyCb(self, text):
+    def _history_cb(self, text):
         self.set_edit_text(text)
         self.set_edit_pos(len(text))
 
@@ -163,25 +163,25 @@
         and move the index of the temporary history stack."""
         if key == a_key['MODAL_ESCAPE']:
             # first save the text to the current mode, then change to NORMAL
-            self.host._updateInputHistory(self.get_edit_text(), mode=self.mode)
-            self.host._updateInputHistory(mode=C.MODE_NORMAL)
+            self.host._update_input_history(self.get_edit_text(), mode=self.mode)
+            self.host._update_input_history(mode=C.MODE_NORMAL)
         if self._mode == C.MODE_NORMAL and key in self._modes:
-            self.host._updateInputHistory(mode=self._modes[key][0])
+            self.host._update_input_history(mode=self._modes[key][0])
         if key == a_key['HISTORY_PREV']:
-            self.host._updateInputHistory(self.get_edit_text(), -1, self._historyCb, self.mode)
+            self.host._update_input_history(self.get_edit_text(), -1, self._history_cb, self.mode)
             return
         elif key == a_key['HISTORY_NEXT']:
-            self.host._updateInputHistory(self.get_edit_text(), +1, self._historyCb, self.mode)
+            self.host._update_input_history(self.get_edit_text(), +1, self._history_cb, self.mode)
             return
         elif key == a_key['EDIT_ENTER']:
-            self.host._updateInputHistory(self.get_edit_text(), mode=self.mode)
+            self.host._update_input_history(self.get_edit_text(), mode=self.mode)
         else:
             if (self._mode == C.MODE_INSERTION
                 and isinstance(self.host.selected_widget, quick_chat.QuickChat)
                 and key not in sat_widgets.FOCUS_KEYS
                 and key not in (a_key['HISTORY_PREV'], a_key['HISTORY_NEXT'])
                 and self.host.sync):
-                self.host.bridge.chatStateComposing(self.host.selected_widget.target, self.host.selected_widget.profile)
+                self.host.bridge.chat_state_composing(self.host.selected_widget.target, self.host.selected_widget.profile)
 
         return super(EditBar, self).keypress(size, key)
 
@@ -203,12 +203,12 @@
         for position in self.positions:
             setattr(self,
                     position,
-                    property(lambda: self, self.widgetGet(position=position),
-                             lambda pos, new_wid: self.widgetSet(new_wid, position=pos))
+                    property(lambda: self, self.widget_get(position=position),
+                             lambda pos, new_wid: self.widget_set(new_wid, position=pos))
                    )
         self.focus_position = len(self.contents)-1
 
-    def getVisiblePositions(self, keep=None):
+    def get_visible_positions(self, keep=None):
         """Return positions that are not hidden in the right order
 
         @param keep: if not None, this position will be keep in the right order, even if it's hidden
@@ -241,27 +241,27 @@
             if focus in self._hidden:
                 return
 
-            self.focus_position = self.getVisiblePositions().index(focus)
+            self.focus_position = self.get_visible_positions().index(focus)
             return
 
         return super(PrimitivusTopWidget, self).keypress(size, key)
 
-    def widgetGet(self,  position):
+    def widget_get(self,  position):
         if not position in self.positions:
             raise ValueError("Unknown position {}".format(position))
         return getattr(self, "_{}".format(position))
 
-    def widgetSet(self,  widget, position):
+    def widget_set(self,  widget, position):
         if not position in self.positions:
             raise ValueError("Unknown position {}".format(position))
         return setattr(self, "_{}".format(position), widget)
 
-    def hideSwitch(self, position):
+    def hide_switch(self, position):
         if not position in self.can_hide:
             raise ValueError("Can't switch position {}".format(position))
         hide = not position in self._hidden
-        widget = self.widgetGet(position)
-        idx = self.getVisiblePositions(position).index(position)
+        widget = self.widget_get(position)
+        idx = self.get_visible_positions(position).index(position)
         if hide:
             del self.contents[idx]
             self._hidden.add(position)
@@ -271,11 +271,11 @@
 
     def show(self, position):
         if position in self._hidden:
-            self.hideSwitch(position)
+            self.hide_switch(position)
 
     def hide(self, position):
         if not position in self._hidden:
-            self.hideSwitch(position)
+            self.hide_switch(position)
 
 
 class PrimitivusApp(QuickApp, InputHistory):
@@ -289,33 +289,33 @@
             sys.exit(3)
         else:
             log.debug(u"Loading {} bridge".format(bridge_name))
-        QuickApp.__init__(self, bridge_factory=bridge_module.Bridge, xmlui=xmlui, check_options=quick_utils.check_options, connect_bridge=False)
+        QuickApp.__init__(self, bridge_factory=bridge_module.bridge, xmlui=xmlui, check_options=quick_utils.check_options, connect_bridge=False)
         ## main loop setup ##
         event_loop = urwid.GLibEventLoop if 'dbus' in bridge_name else urwid.TwistedEventLoop
-        self.loop = urwid.MainLoop(urwid.SolidFill(), C.PALETTE, event_loop=event_loop(), input_filter=self.inputFilter, unhandled_input=self.keyHandler)
+        self.loop = urwid.MainLoop(urwid.SolidFill(), C.PALETTE, event_loop=event_loop(), input_filter=self.input_filter, unhandled_input=self.key_handler)
 
     @classmethod
     def run(cls):
         cls().start()
 
-    def onBridgeConnected(self):
+    def on_bridge_connected(self):
 
         ##misc setup##
         self._visible_widgets = set()
         self.notif_bar = sat_widgets.NotificationBar()
-        urwid.connect_signal(self.notif_bar, 'change', self.onNotification)
+        urwid.connect_signal(self.notif_bar, 'change', self.on_notification)
 
-        self.progress_wid = self.widgets.getOrCreateWidget(Progress, None, on_new_widget=None)
-        urwid.connect_signal(self.notif_bar.progress, 'click', lambda x: self.selectWidget(self.progress_wid))
+        self.progress_wid = self.widgets.get_or_create_widget(Progress, None, on_new_widget=None)
+        urwid.connect_signal(self.notif_bar.progress, 'click', lambda x: self.select_widget(self.progress_wid))
         self.__saved_overlay = None
 
         self.x_notify = Notify()
 
         # we already manage exit with a_key['APP_QUIT'], so we don't want C-c
         signal.signal(signal.SIGINT, signal.SIG_IGN)
-        sat_conf = sat_config.parseMainConf()
+        sat_conf = sat_config.parse_main_conf()
         self._bracketed_paste = C.bool(
-            sat_config.getConfig(sat_conf, C.CONFIG_SECTION, 'bracketed_paste', 'false')
+            sat_config.config_get(sat_conf, C.CONFIG_SECTION, 'bracketed_paste', 'false')
         )
         if self._bracketed_paste:
             log.debug("setting bracketed paste mode as requested")
@@ -323,7 +323,7 @@
             self._bracketed_mode_set = True
 
         self.loop.widget = self.main_widget = ProfileManager(self)
-        self.postInit()
+        self.post_init()
 
     @property
     def visible_widgets(self):
@@ -337,7 +337,7 @@
     def mode(self, value):
         self.editBar.mode = value
 
-    def modeHint(self, value):
+    def mode_hint(self, value):
         """Change mode if make sens (i.e.: if there is nothing in the editBar)"""
         if not self.editBar.get_edit_text():
             self.mode = value
@@ -366,22 +366,22 @@
             pass
 
     def start(self):
-        self.connectBridge()
+        self.connect_bridge()
         self.loop.run()
 
-    def postInit(self):
+    def post_init(self):
         try:
-            config.applyConfig(self)
+            config.apply_config(self)
         except Exception as e:
             log.error(u"configuration error: {}".format(e))
             popup = self.alert(_(u"Configuration Error"), _(u"Something went wrong while reading the configuration, please check :messages"))
             if self.options.profile:
                 self._early_popup = popup
             else:
-                self.showPopUp(popup)
-        super(PrimitivusApp, self).postInit(self.main_widget)
+                self.show_pop_up(popup)
+        super(PrimitivusApp, self).post_init(self.main_widget)
 
-    def keysToText(self, keys):
+    def keys_to_text(self, keys):
         """Generator return normal text from urwid keys"""
         for k in keys:
             if k == 'tab':
@@ -391,7 +391,7 @@
             elif is_wide_char(k,0) or (len(k)==1 and ord(k) >= 32):
                 yield k
 
-    def inputFilter(self, input_, raw):
+    def input_filter(self, input_, raw):
         if self.__saved_overlay and input_ != a_key['OVERLAY_HIDE']:
             return
 
@@ -439,7 +439,7 @@
                 if self.main_widget.focus == edit_bar:
                     # XXX: if a paste is detected, we append it directly to the edit bar text
                     #      so the user can check it and press [enter] if it's OK
-                    buf_paste = u''.join(self.keysToText(input_))
+                    buf_paste = u''.join(self.keys_to_text(input_))
                     pos = edit_bar.edit_pos
                     edit_bar.set_edit_text(u'{}{}{}'.format(edit_bar.edit_text[:pos], buf_paste, edit_bar.edit_text[pos:]))
                     edit_bar.edit_pos+=len(buf_paste)
@@ -463,16 +463,16 @@
                         input_[input_.index(i)] = a_key['HISTORY_NEXT']
         return input_
 
-    def keyHandler(self, input_):
+    def key_handler(self, input_):
         if input_ == a_key['MENU_HIDE']:
             """User want to (un)hide the menu roller"""
             try:
-                self.main_widget.hideSwitch('menu')
+                self.main_widget.hide_switch('menu')
             except AttributeError:
                 pass
         elif input_ == a_key['NOTIFICATION_NEXT']:
             """User wants to see next notification"""
-            self.notif_bar.showNext()
+            self.notif_bar.show_next()
         elif input_ == a_key['OVERLAY_HIDE']:
             """User wants to (un)hide overlay window"""
             if isinstance(self.loop.widget,urwid.Overlay):
@@ -483,7 +483,7 @@
                     self.loop.widget = self.__saved_overlay
                     self.__saved_overlay = None
 
-        elif input_ == a_key['DEBUG'] and 'D' in self.bridge.getVersion(): #Debug only for dev versions
+        elif input_ == a_key['DEBUG'] and 'D' in self.bridge.version_get(): #Debug only for dev versions
             self.debug()
         elif input_ == a_key['CONTACTS_HIDE']: #user wants to (un)hide the contact lists
             try:
@@ -507,74 +507,74 @@
                     self.loop.widget = self.save_main_widget
                     del self.save_main_widget
         try:
-            return self.menu_roller.checkShortcuts(input_)
+            return self.menu_roller.check_shortcuts(input_)
         except AttributeError:
             return input_
 
-    def addMenus(self, menu, type_filter, menu_data=None):
+    def add_menus(self, menu, type_filter, menu_data=None):
         """Add cached menus to instance
         @param menu: sat_widgets.Menu instance
-        @param type_filter: menu type like is sat.core.sat_main.importMenu
+        @param type_filter: menu type like is sat.core.sat_main.import_menu
         @param menu_data: data to send with these menus
 
         """
         def add_menu_cb(callback_id):
-            self.launchAction(callback_id, menu_data, profile=self.current_profile)
-        for id_, type_, path, path_i18n, extra  in self.bridge.menusGet("", C.NO_SECURITY_LIMIT ): # TODO: manage extra
+            self.action_launch(callback_id, menu_data, profile=self.current_profile)
+        for id_, type_, path, path_i18n, extra  in self.bridge.menus_get("", C.NO_SECURITY_LIMIT ): # TODO: manage extra
             if type_ != type_filter:
                 continue
             if len(path) != 2:
                 raise NotImplementedError("Menu with a path != 2 are not implemented yet")
-            menu.addMenu(path_i18n[0], path_i18n[1], lambda dummy,id_=id_: add_menu_cb(id_))
+            menu.add_menu(path_i18n[0], path_i18n[1], lambda dummy,id_=id_: add_menu_cb(id_))
 
 
-    def _buildMenuRoller(self):
+    def _build_menu_roller(self):
         menu = sat_widgets.Menu(self.loop)
         general = _("General")
-        menu.addMenu(general, _("Connect"), self.onConnectRequest)
-        menu.addMenu(general, _("Disconnect"), self.onDisconnectRequest)
-        menu.addMenu(general, _("Parameters"), self.onParam)
-        menu.addMenu(general, _("About"), self.onAboutRequest)
-        menu.addMenu(general, _("Exit"), self.onExitRequest, a_key['APP_QUIT'])
-        menu.addMenu(_("Contacts"))  # add empty menu to save the place in the menu order
+        menu.add_menu(general, _("Connect"), self.on_connect_request)
+        menu.add_menu(general, _("Disconnect"), self.on_disconnect_request)
+        menu.add_menu(general, _("Parameters"), self.on_param)
+        menu.add_menu(general, _("About"), self.on_about_request)
+        menu.add_menu(general, _("Exit"), self.on_exit_request, a_key['APP_QUIT'])
+        menu.add_menu(_("Contacts"))  # add empty menu to save the place in the menu order
         groups = _("Groups")
-        menu.addMenu(groups)
-        menu.addMenu(groups, _("Join room"), self.onJoinRoomRequest, a_key['ROOM_JOIN'])
+        menu.add_menu(groups)
+        menu.add_menu(groups, _("Join room"), self.on_join_room_request, a_key['ROOM_JOIN'])
         #additionals menus
         #FIXME: do this in a more generic way (in quickapp)
-        self.addMenus(menu, C.MENU_GLOBAL)
+        self.add_menus(menu, C.MENU_GLOBAL)
 
         menu_roller = sat_widgets.MenuRoller([(_('Main menu'), menu, C.MENU_ID_MAIN)])
         return menu_roller
 
-    def _buildMainWidget(self):
+    def _build_main_widget(self):
         self.contact_lists_pile = urwid.Pile([])
         #self.center_part = urwid.Columns([('weight',2,self.contact_lists[profile]),('weight',8,Chat('',self))])
         self.center_part = urwid.Columns([('weight', 2, self.contact_lists_pile), ('weight', 8, urwid.Filler(urwid.Text('')))])
 
         self.editBar = EditBar(self)
-        self.menu_roller = self._buildMenuRoller()
+        self.menu_roller = self._build_menu_roller()
         self.main_widget = PrimitivusTopWidget(self.center_part, self.menu_roller, self.notif_bar, self.editBar)
         return self.main_widget
 
     def plugging_profiles(self):
-        self.loop.widget = self._buildMainWidget()
+        self.loop.widget = self._build_main_widget()
         self.redraw()
         try:
             # if a popup arrived before main widget is build, we need to show it now
-            self.showPopUp(self._early_popup)
+            self.show_pop_up(self._early_popup)
         except AttributeError:
             pass
         else:
             del self._early_popup
 
-    def profilePlugged(self, profile):
-        QuickApp.profilePlugged(self, profile)
-        contact_list = self.widgets.getOrCreateWidget(ContactList, None, on_new_widget=None, on_click=self.contactSelected, on_change=lambda w: self.redraw(), profile=profile)
+    def profile_plugged(self, profile):
+        QuickApp.profile_plugged(self, profile)
+        contact_list = self.widgets.get_or_create_widget(ContactList, None, on_new_widget=None, on_click=self.contact_selected, on_change=lambda w: self.redraw(), profile=profile)
         self.contact_lists_pile.contents.append((contact_list, ('weight', 1)))
         return contact_list
 
-    def isHidden(self):
+    def is_hidden(self):
         """Tells if the frontend window is hidden.
 
         @return bool
@@ -590,11 +590,11 @@
         @return (urwid_satext.Alert): the created Alert instance
         """
         popup = sat_widgets.Alert(title, message)
-        popup.setCallback('ok', lambda dummy: self.removePopUp(popup))
-        self.showPopUp(popup, width=75, height=20)
+        popup.set_callback('ok', lambda dummy: self.remove_pop_up(popup))
+        self.show_pop_up(popup, width=75, height=20)
         return popup
 
-    def removePopUp(self, widget=None):
+    def remove_pop_up(self, widget=None):
         """Remove current pop-up, and if there is other in queue, show it
 
         @param widget(None, urwid.Widget): if not None remove this popup from front or queue
@@ -607,19 +607,19 @@
                 current_popup = self.loop.widget.top_w
                 if not current_popup == widget:
                     try:
-                        self.notif_bar.removePopUp(widget)
+                        self.notif_bar.remove_pop_up(widget)
                     except ValueError:
                         log.warning(u"Trying to remove an unknown widget {}".format(widget))
                     return
         self.loop.widget = self.main_widget
-        next_popup = self.notif_bar.getNextPopup()
+        next_popup = self.notif_bar.get_next_popup()
         if next_popup:
             #we still have popup to show, we display it
-            self.showPopUp(next_popup)
+            self.show_pop_up(next_popup)
         else:
             self.redraw()
 
-    def showPopUp(self, pop_up_widget, width=None, height=None, align='center',
+    def show_pop_up(self, pop_up_widget, width=None, height=None, align='center',
                   valign='middle'):
         """Show a pop-up window if possible, else put it in queue
 
@@ -640,11 +640,11 @@
             self.loop.widget = display_widget
             self.redraw()
         else:
-            self.notif_bar.addPopUp(pop_up_widget)
+            self.notif_bar.add_pop_up(pop_up_widget)
 
-    def barNotify(self, message):
+    def bar_notify(self, message):
         """"Notify message to user via notification bar"""
-        self.notif_bar.addMessage(message)
+        self.notif_bar.add_message(message)
         self.redraw()
 
     def notify(self, type_, entity=None, message=None, subject=None, callback=None, cb_args=None, widget=None, profile=C.PROF_KEY_NONE):
@@ -653,15 +653,15 @@
             # still do a desktop notification is the X window has not the focus
             super(PrimitivusApp, self).notify(type_, entity, message, subject, callback, cb_args, widget, profile)
         # we don't want notifications without message on desktop
-        if message is not None and not self.x_notify.hasFocus():
+        if message is not None and not self.x_notify.has_focus():
             if message is None:
                 message = _("{app}: a new event has just happened{entity}").format(
                     app=C.APP_NAME,
                     entity=u' ({})'.format(entity) if entity else '')
-            self.x_notify.sendNotification(message)
+            self.x_notify.send_notification(message)
 
 
-    def newWidget(self, widget, user_action=False):
+    def new_widget(self, widget, user_action=False):
         """Method called when a new widget is created
 
         if suitable, the widget will be displayed
@@ -672,9 +672,9 @@
         # FIXME: when several widgets are possible (e.g. with :split)
         #        do not replace current widget when self.selected_widget != None
         if user_action or self.selected_widget is None:
-            self.selectWidget(widget)
+            self.select_widget(widget)
 
-    def selectWidget(self, widget):
+    def select_widget(self, widget):
         """Display a widget if possible,
 
         else add it in the notification bar queue
@@ -684,27 +684,27 @@
         wid_idx = len(self.center_part.widget_list)-1
         self.center_part.widget_list[wid_idx] = widget
         try:
-            self.menu_roller.removeMenu(C.MENU_ID_WIDGET)
+            self.menu_roller.remove_menu(C.MENU_ID_WIDGET)
         except KeyError:
             log.debug("No menu to delete")
         self.selected_widget = widget
         try:
-            onSelected = self.selected_widget.onSelected
+            on_selected = self.selected_widget.on_selected
         except AttributeError:
             pass
         else:
-            onSelected()
+            on_selected()
         self._visible_widgets = set([widget]) # XXX: we can only have one widget visible at the time for now
         self.contact_lists.select(None)
 
-        for wid in self.visible_widgets: # FIXME: check if widgets.getWidgets is not more appropriate
+        for wid in self.visible_widgets: # FIXME: check if widgets.get_widgets is not more appropriate
             if isinstance(wid, Chat):
                 contact_list = self.contact_lists[wid.profile]
                 contact_list.select(wid.target)
 
         self.redraw()
 
-    def removeWindow(self):
+    def remove_window(self):
         """Remove window showed on the right column"""
         #TODO: better Window management than this hack
         assert len(self.center_part.widget_list) <= 2
@@ -713,7 +713,7 @@
         self.center_part.focus_position = 0
         self.redraw()
 
-    def addProgress(self, pid, message, profile):
+    def add_progress(self, pid, message, profile):
         """Follow a SàT progression
 
         @param pid: progression id
@@ -721,118 +721,118 @@
         """
         self.progress_wid.add(pid, message, profile)
 
-    def setProgress(self, percentage):
+    def set_progress(self, percentage):
         """Set the progression shown in notification bar"""
-        self.notif_bar.setProgress(percentage)
+        self.notif_bar.set_progress(percentage)
 
-    def contactSelected(self, contact_list, entity):
-        self.clearNotifs(entity, profile=contact_list.profile)
+    def contact_selected(self, contact_list, entity):
+        self.clear_notifs(entity, profile=contact_list.profile)
         if entity.resource:
             # we have clicked on a private MUC conversation
-            chat_widget = self.widgets.getOrCreateWidget(Chat, entity, on_new_widget=None, force_hash = Chat.getPrivateHash(contact_list.profile, entity), profile=contact_list.profile)
+            chat_widget = self.widgets.get_or_create_widget(Chat, entity, on_new_widget=None, force_hash = Chat.get_private_hash(contact_list.profile, entity), profile=contact_list.profile)
         else:
-            chat_widget = self.widgets.getOrCreateWidget(Chat, entity, on_new_widget=None, profile=contact_list.profile)
-        self.selectWidget(chat_widget)
-        self.menu_roller.addMenu(_('Chat menu'), chat_widget.getMenu(), C.MENU_ID_WIDGET)
+            chat_widget = self.widgets.get_or_create_widget(Chat, entity, on_new_widget=None, profile=contact_list.profile)
+        self.select_widget(chat_widget)
+        self.menu_roller.add_menu(_('Chat menu'), chat_widget.get_menu(), C.MENU_ID_WIDGET)
 
-    def _dialogOkCb(self, widget, data):
+    def _dialog_ok_cb(self, widget, data):
         popup, answer_cb, answer_data = data
-        self.removePopUp(popup)
+        self.remove_pop_up(popup)
         if answer_cb is not None:
             answer_cb(True, answer_data)
 
-    def _dialogCancelCb(self, widget, data):
+    def _dialog_cancel_cb(self, widget, data):
         popup, answer_cb, answer_data = data
-        self.removePopUp(popup)
+        self.remove_pop_up(popup)
         if answer_cb is not None:
             answer_cb(False, answer_data)
 
-    def showDialog(self, message, title="", type="info", answer_cb = None, answer_data = None):
+    def show_dialog(self, message, title="", type="info", answer_cb = None, answer_data = None):
         if type == 'info':
             popup = sat_widgets.Alert(title, message, ok_cb=answer_cb)
             if answer_cb is None:
-                popup.setCallback('ok', lambda dummy: self.removePopUp(popup))
+                popup.set_callback('ok', lambda dummy: self.remove_pop_up(popup))
         elif type == 'error':
             popup = sat_widgets.Alert(title, message, ok_cb=answer_cb)
             if answer_cb is None:
-                popup.setCallback('ok', lambda dummy: self.removePopUp(popup))
+                popup.set_callback('ok', lambda dummy: self.remove_pop_up(popup))
         elif type == 'yes/no':
             popup = sat_widgets.ConfirmDialog(message)
-            popup.setCallback('yes', self._dialogOkCb, (popup, answer_cb, answer_data))
-            popup.setCallback('no', self._dialogCancelCb, (popup, answer_cb, answer_data))
+            popup.set_callback('yes', self._dialog_ok_cb, (popup, answer_cb, answer_data))
+            popup.set_callback('no', self._dialog_cancel_cb, (popup, answer_cb, answer_data))
         else:
             popup = sat_widgets.Alert(title, message, ok_cb=answer_cb)
             if answer_cb is None:
-                popup.setCallback('ok', lambda dummy: self.removePopUp(popup))
+                popup.set_callback('ok', lambda dummy: self.remove_pop_up(popup))
             log.error(u'unmanaged dialog type: {}'.format(type))
-        self.showPopUp(popup)
+        self.show_pop_up(popup)
 
-    def dialogFailure(self, failure):
+    def dialog_failure(self, failure):
         """Show a failure that has been returned by an asynchronous bridge method.
 
         @param failure (defer.Failure): Failure instance
         """
         self.alert(failure.classname, failure.message)
 
-    def onNotification(self, notif_bar):
+    def on_notification(self, notif_bar):
         """Called when a new notification has been received"""
         if not isinstance(self.main_widget, PrimitivusTopWidget):
             #if we are not in the main configuration, we ignore the notifications bar
             return
-        if self.notif_bar.canHide():
+        if self.notif_bar.can_hide():
                 #No notification left, we can hide the bar
                 self.main_widget.hide('notif_bar')
         else:
             self.main_widget.show('notif_bar')
             self.redraw() # FIXME: invalidate cache in a more efficient way
 
-    def _actionManagerUnknownError(self):
+    def _action_manager_unknown_error(self):
         self.alert(_("Error"), _(u"Unmanaged action"))
 
-    def roomJoinedHandler(self, room_jid_s, room_nicks, user_nick, subject, profile):
-        super(PrimitivusApp, self).roomJoinedHandler(room_jid_s, room_nicks, user_nick, subject, profile)
+    def room_joined_handler(self, room_jid_s, room_nicks, user_nick, subject, profile):
+        super(PrimitivusApp, self).room_joined_handler(room_jid_s, room_nicks, user_nick, subject, profile)
         # if self.selected_widget is None:
-        #     for contact_list in self.widgets.getWidgets(ContactList):
+        #     for contact_list in self.widgets.get_widgets(ContactList):
         #         if profile in contact_list.profiles:
-        #             contact_list.setFocus(jid.JID(room_jid_s), True)
+        #             contact_list.set_focus(jid.JID(room_jid_s), True)
 
-    def progressStartedHandler(self, pid, metadata, profile):
-        super(PrimitivusApp, self).progressStartedHandler(pid, metadata, profile)
-        self.addProgress(pid, metadata.get('name', _(u'unkown')), profile)
+    def progress_started_handler(self, pid, metadata, profile):
+        super(PrimitivusApp, self).progress_started_handler(pid, metadata, profile)
+        self.add_progress(pid, metadata.get('name', _(u'unkown')), profile)
 
-    def progressFinishedHandler(self, pid, metadata, profile):
+    def progress_finished_handler(self, pid, metadata, profile):
         log.info(u"Progress {} finished".format(pid))
-        super(PrimitivusApp, self).progressFinishedHandler(pid, metadata, profile)
+        super(PrimitivusApp, self).progress_finished_handler(pid, metadata, profile)
 
-    def progressErrorHandler(self, pid, err_msg, profile):
+    def progress_error_handler(self, pid, err_msg, profile):
         log.warning(u"Progress {pid} error: {err_msg}".format(pid=pid, err_msg=err_msg))
-        super(PrimitivusApp, self).progressErrorHandler(pid, err_msg, profile)
+        super(PrimitivusApp, self).progress_error_handler(pid, err_msg, profile)
 
 
     ##DIALOGS CALLBACKS##
-    def onJoinRoom(self, button, edit):
-        self.removePopUp()
+    def on_join_room(self, button, edit):
+        self.remove_pop_up()
         room_jid = jid.JID(edit.get_edit_text())
-        self.bridge.mucJoin(room_jid, self.profiles[self.current_profile].whoami.node, {}, self.current_profile, callback=lambda dummy: None, errback=self.dialogFailure)
+        self.bridge.muc_join(room_jid, self.profiles[self.current_profile].whoami.node, {}, self.current_profile, callback=lambda dummy: None, errback=self.dialog_failure)
 
     #MENU EVENTS#
-    def onConnectRequest(self, menu):
+    def on_connect_request(self, menu):
         QuickApp.connect(self, self.current_profile)
 
-    def onDisconnectRequest(self, menu):
+    def on_disconnect_request(self, menu):
         self.disconnect(self.current_profile)
 
-    def onParam(self, menu):
+    def on_param(self, menu):
         def success(params):
             ui = xmlui.create(self, xml_data=params, profile=self.current_profile)
             ui.show()
 
         def failure(error):
             self.alert(_("Error"), _("Can't get parameters (%s)") % error)
-        self.bridge.getParamsUI(app=C.APP_NAME, profile_key=self.current_profile, callback=success, errback=failure)
+        self.bridge.param_ui_get(app=C.APP_NAME, profile_key=self.current_profile, callback=success, errback=failure)
 
-    def onExitRequest(self, menu):
-        QuickApp.onExit(self)
+    def on_exit_request(self, menu):
+        QuickApp.on_exit(self)
         try:
             if self._bracketed_mode_set: # we don't unset if bracketed paste mode was detected automatically (i.e. not in conf)
                 log.debug("unsetting bracketed paste mode")
@@ -841,21 +841,21 @@
             pass
         raise urwid.ExitMainLoop()
 
-    def onJoinRoomRequest(self, menu):
+    def on_join_room_request(self, menu):
         """User wants to join a MUC room"""
-        pop_up_widget = sat_widgets.InputDialog(_("Entering a MUC room"), _("Please enter MUC's JID"), default_txt=self.bridge.mucGetDefaultService(), ok_cb=self.onJoinRoom)
-        pop_up_widget.setCallback('cancel', lambda dummy: self.removePopUp(pop_up_widget))
-        self.showPopUp(pop_up_widget)
+        pop_up_widget = sat_widgets.InputDialog(_("Entering a MUC room"), _("Please enter MUC's JID"), default_txt=self.bridge.muc_get_default_service(), ok_cb=self.on_join_room)
+        pop_up_widget.set_callback('cancel', lambda dummy: self.remove_pop_up(pop_up_widget))
+        self.show_pop_up(pop_up_widget)
 
-    def onAboutRequest(self, menu):
-        self.alert(_("About"), C.APP_NAME + " v" + self.bridge.getVersion())
+    def on_about_request(self, menu):
+        self.alert(_("About"), C.APP_NAME + " v" + self.bridge.version_get())
 
     #MISC CALLBACKS#
 
-    def setPresenceStatus(self, show='', status=None, profile=C.PROF_KEY_NONE):
-        contact_list_wid = self.widgets.getWidget(ContactList, profiles=profile)
+    def set_presence_status(self, show='', status=None, profile=C.PROF_KEY_NONE):
+        contact_list_wid = self.widgets.get_widget(ContactList, profiles=profile)
         if contact_list_wid is not None:
-            contact_list_wid.status_bar.setPresenceStatus(show, status)
+            contact_list_wid.status_bar.set_presence_status(show, status)
         else:
             log.warning(u"No ContactList widget found for profile {}".format(profile))