def _close_application_shutdown_callback(self, instance_id=None):
     if instance_id is not None:
         self._number_of_ongoing_calls = self._number_of_ongoing_calls - 1
     if self._number_of_ongoing_calls == 0:
         qDebug('PluginManager.close_application() completed')
         self._number_of_ongoing_calls = None
         self._close_application_signal()

 def _save_settings_callback(self, instance_id=None):
     if instance_id is not None:
         self._number_of_ongoing_calls = self._number_of_ongoing_calls - 1
     if self._number_of_ongoing_calls == 0:
         qDebug('PluginManager.save_settings() completed')
         self._number_of_ongoing_calls = None
         self.save_settings_completed_signal.emit()

    def _switch_perspective(self, name, settings_changed, save_before, without_plugin_changes=False):
        # convert from unicode
        name = str(name.replace('/', '__'))

        qDebug('PerspectiveManager.switch_perspective() switching to perspective "%s"' % name)
        if self._current_perspective is not None and self._menu_manager is not None:
            self._menu_manager.set_item_checked(self._current_perspective, False)
            self._menu_manager.set_item_disabled(self._current_perspective, False)

        # create perspective if necessary
        if name not in self.perspectives:
            self._create_perspective(name, clone_perspective=False)

        # update current perspective
        self._current_perspective = name
        if self._menu_manager is not None:
            self._menu_manager.set_item_checked(self._current_perspective, True)
            self._menu_manager.set_item_disabled(self._current_perspective, True)
        if not self._current_perspective.startswith(self.HIDDEN_PREFIX):
            self._settings_proxy.set_value('', 'current-perspective', self._current_perspective)
        self._perspective_settings = self._get_perspective_settings(self._current_perspective)

        # emit signals
        self.perspective_changed_signal.emit(self._current_perspective.lstrip(self.HIDDEN_PREFIX))
        if settings_changed:
            if not without_plugin_changes:
                self.restore_settings_signal.emit(self._global_settings, self._perspective_settings)
            else:
                self.restore_settings_without_plugin_changes_signal.emit(self._global_settings, self._perspective_settings)

 def _init_node(self):
     # initialize node once
     if not self._node_initialized:
         name = 'rqt_gui_py_node_%d' % os.getpid()
         qDebug('RosPyPluginProvider._init_node() initialize ROS node "%s"' % name)
         rospy.init_node(name, disable_signals=True)
         self._node_initialized = True

 def load_plugin(self, plugin_id, serial_number=None, argv=None):
     qDebug('PluginManager.load_plugin(%s, %s)' % (str(plugin_id), str(serial_number) if serial_number is not None else ''))
     # save state of top-level widgets
     self.plugins_about_to_change_signal.emit()
     if serial_number is None:
         serial_number = self._next_serial_number(plugin_id)
     instance_id = PluginInstanceId(plugin_id, serial_number)
     self._load_plugin_load(instance_id, self._load_plugin_restore, argv)

 def emit_save_settings_completed(self):
     qDebug('PluginHandler.emit_save_settings_completed()')
     self._call_method_on_all_dock_widgets('save_settings', self.__instance_settings)
     self.__instance_settings = None
     if self.__callback is not None:
         callback = self.__callback
         self.__callback = None
         callback(self._instance_id)

 def save_settings(self, global_settings, perspective_settings):
     qDebug('MainWindow.save_settings()')
     self._global_settings = global_settings
     self._perspective_settings = perspective_settings
     self._settings = self._perspective_settings.get_settings('mainwindow')
     # store current setup to current _settings
     self._save_geometry_to_perspective()
     self._save_state_to_perspective()

 def restore_settings(self, global_settings, perspective_settings):
     qDebug('MainWindow.restore_settings()')
     # remember new _settings
     self._global_settings = global_settings
     self._perspective_settings = perspective_settings
     self._settings = self._perspective_settings.get_settings('mainwindow')
     # only restore geometry, restoring state is triggered after PluginManager has been updated
     self._restore_geometry_from_perspective()

 def _restore_settings_restore_callback(self, instance_id=None):
     if instance_id is not None:
         self._number_of_ongoing_calls = self._number_of_ongoing_calls - 1
     if self._number_of_ongoing_calls == 0:
         if instance_id is not None:
             qDebug('PluginManager.restore_settings() all plugin settings restored')
         self._number_of_ongoing_calls = None
         # restore state of top-level widgets
         self.plugins_changed_signal.emit()

 def _restore_settings_load_missing_callback(self, handler=None, exception=None):
     if handler is not None:
         self._number_of_ongoing_calls = self._number_of_ongoing_calls - 1
         self._load_plugin_completed(handler, exception)
     if self._number_of_ongoing_calls == 0:
         if handler is not None:
             qDebug('PluginManager.restore_settings() all missing plugins loaded')
         self._number_of_ongoing_calls = None
         self._restore_settings_restore()

 def _restore_settings_unload_obsolete_callback(self, instance_id=None):
     if instance_id is not None:
         self._number_of_ongoing_calls = self._number_of_ongoing_calls - 1
         self._remove_running_plugin(instance_id)
     if self._number_of_ongoing_calls == 0:
         if instance_id is not None:
             qDebug('PluginManager.restore_settings() all obsolete plugins unloaded')
         self._number_of_ongoing_calls = None
         self._restore_settings_load_missing()

 def emit_restore_settings_completed(self):
     qDebug('PluginHandler.emit_restore_settings_completed()')
     # call after plugin has restored settings as it may spawn additional dock widgets
     self._call_method_on_all_dock_widgets('restore_settings', self.__instance_settings)
     self.__instance_settings = None
     if self.__callback is not None:
         callback = self.__callback
         self.__callback = None
         callback(self._instance_id)

 def _save_settings_from_remote(self):
     qDebug('PluginHandlerXEmbedClient._save_settings_from_remote()')
     try:
         plugin_settings = Settings(self._remote_plugin_settings, '')
         instance_settings = Settings(self._remote_instance_settings, '')
         self._save_settings(plugin_settings, instance_settings)
     except Exception:
         qCritical('PluginHandlerXEmbedClient._save_settings_from_remote() plugin "%s" raised an exception:\n%s' % (str(self._instance_id), traceback.format_exc()))
         self.emit_save_settings_completed()

 def closeEvent(self, event):
     qDebug('MainWindow.closeEvent()')
     if not self._save_on_close_signaled:
         self._save_geometry_to_perspective()
         self._save_state_to_perspective()
         self._save_on_close_signaled = True
         self.save_settings_before_close_signal.emit(self._global_settings, self._perspective_settings)
         event.ignore()
     else:
         event.accept()

 def unload_plugin(self, instance_id_str):
     # unloading a plugin with locked perspective or running standalone triggers close of application
     if self._application_context.options.lock_perspective or self._application_context.options.standalone_plugin:
         self._close_application_signal()
         return
     instance_id = PluginInstanceId(instance_id=instance_id_str)
     qDebug('PluginManager.unload_plugin(%s)' % str(instance_id))
     # save state of top-level widgets
     self.plugins_about_to_change_signal.emit()
     # save settings before shutdown and unloading
     self._save_plugin_settings(instance_id, self._unload_plugin_shutdown)

 def _save_settings(self, global_settings, perspective_settings, callback):
     qDebug('PluginManager.save_settings()')
     self._global_settings = global_settings.get_settings('pluginmanager')
     self._perspective_settings = perspective_settings.get_settings('pluginmanager')
     self._store_running_plugins()
     # trigger async call on all running plugins
     self._number_of_ongoing_calls = len(self._running_plugins)
     if self._number_of_ongoing_calls > 0:
         for info in self._running_plugins.values():
             self._save_plugin_settings(info['instance_id'], callback)
     else:
         callback()

 def restore_settings(self, plugin_settings, instance_settings, callback=None):
     """
     Restore settings of the plugin (`Plugin.restore_settings()`) and all dock widget title bars.
     Completion is signaled asynchronously if a callback is passed.
     """
     qDebug('PluginHandler.restore_settings()')
     self.__instance_settings = instance_settings
     self.__callback = callback
     try:
         self._restore_settings(plugin_settings, instance_settings)
     except Exception:
         qCritical('PluginHandler.restore_settings() plugin "%s" raised an exception:\n%s' % (str(self._instance_id), traceback.format_exc()))
         self.emit_restore_settings_completed()

 def _restore_settings_save_obsolete(self):
     # trigger shutdown of obsolete plugins
     plugins = self._restore_running_plugins_get_plugins()
     obsolete = []
     for instance_id in self._running_plugins.keys():
         if instance_id not in plugins.keys():
             obsolete.append(PluginInstanceId(instance_id=instance_id))
     self._number_of_ongoing_calls = len(obsolete)
     if self._number_of_ongoing_calls > 0:
         qDebug('PluginManager.restore_settings() unloading %d obsolete plugins' % self._number_of_ongoing_calls)
         for instance_id in obsolete:
             self._shutdown_plugin(instance_id, self._restore_settings_unload_obsolete)
     else:
         self._restore_settings_unload_obsolete_callback()

 def _restore_settings_load_missing(self):
     # trigger_load of not yet loaded plugins
     plugins = self._restore_running_plugins_get_plugins()
     loading = []
     for instance_id_str, instance_id in plugins.items():
         if instance_id_str not in self._running_plugins.keys():
             loading.append(instance_id)
     self._number_of_ongoing_calls = len(loading)
     if self._number_of_ongoing_calls > 0:
         qDebug('PluginManager.restore_settings() loading %d plugins' % self._number_of_ongoing_calls)
         for instance_id in loading:
             self._load_plugin_load(instance_id, self._restore_settings_load_missing_callback)
     else:
         self._restore_settings_load_missing_callback()

 def start_plugin(self, plugin_name, argv):
     qDebug('PluginManagerDBusInterface.start_plugin(%s)' % plugin_name)
     plugins = self._plugin_manager.find_plugins_by_name(plugin_name)
     if len(plugins) == 0:
         msg = 'PluginManagerDBusInterface.start_plugin() found no plugin matching "%s"' % plugin_name
         qWarning(msg)
         return (1, msg)
     elif len(plugins) > 1:
         msg = 'PluginManagerDBusInterface.start_plugin() found multiple plugins matching "%s"\n%s' % (plugin_name, '\n'.join(plugins.values()))
         qWarning(msg)
         return (1, msg)
     plugin_id = plugins.keys()[0]
     self._plugin_manager.load_plugin(plugin_id, argv=argv.split(' ') if argv else [])
     return (0, plugin_id)