Philipp Hörist pushed to branch mainwindow at gajim / gajim

Commits:

11 changed files:

Changes:

  • gajim/common/client.py
    ... ... @@ -306,7 +306,7 @@ def _on_connection_failed(self, _client, _signal_name):
    306 306
    307 307 
         def _on_connected(self, _client, _signal_name):
    308 308 
             self._set_state(ClientState.CONNECTED)
    309 
    -        self.get_module('MUC').get_manager().reset_state()
    309 
    +        self.get_module('MUC').reset_state()
    310 310 
             self.get_module('Discovery').discover_server_info()
    311 311 
             self.get_module('Discovery').discover_account_info()
    312 312 
             self.get_module('Discovery').discover_server_items()

  • gajim/common/modules/caps.py
    ... ... @@ -212,8 +212,7 @@ def preconditions_met(self):
    212 212 
                 return False
    213 213
    214 214 
             if self._from_muc:
    215 
    -            muc = client.get_module('MUC').get_manager().get(
    216 
    -                self.entity.jid.bare)
    215 
    +            muc = client.get_module('MUC').get_muc_data(self.entity.jid.bare)
    217 216
    218 217 
                 if muc is None or not muc.state.is_joined:
    219 218 
                     self.set_obsolete()

  • gajim/common/modules/chat_markers.py
    ... ... @@ -45,8 +45,8 @@ def _process_chat_marker(self, _con, _stanza, properties):
    45 45 
                 return
    46 46
    47 47 
             if properties.type.is_groupchat:
    48 
    -            manager = self._con.get_module('MUC').get_manager()
    49 
    -            muc_data = manager.get(properties.muc_jid)
    48 
    +            muc_data = self._con.get_module('MUC').get_muc_data(
    49 
    +                properties.muc_jid)
    50 50 
                 if muc_data is None:
    51 51 
                     return
    52 52

  • gajim/common/modules/contacts.py
    ... ... @@ -303,6 +303,11 @@ def __init__(self, logger, jid, account):
    303 303 
         def is_groupchat(self):
    304 304 
             return True
    305 305
    306 
    +    @property
    307 
    +    def state(self):
    308 
    +        muc_data = self._module('MUC').get_muc_data(self._jid)
    309 
    +        return muc_data.state
    310 
    +
    306 311 
         def add_resource(self, resource):
    307 312 
             jid = self._jid.new_with(resource=resource)
    308 313 
             contact = GroupchatParticipant(self._log, jid, self._account)
    ... ... @@ -344,14 +349,18 @@ def update_avatar(self, *args):
    344 349 
             app.interface.avatar_storage.invalidate_cache(self._jid)
    345 350 
             self.notify('avatar-update')
    346 351
    352 
    +    @property
    353 
    +    def is_joined(self):
    354 
    +        muc_data = self._module('MUC').get_muc_data(self._jid)
    355 
    +        return muc_data.state.is_joined
    356 
    +
    347 357 
         def set_not_joined(self):
    348 358 
             for contact in self._resources.values():
    349 359 
                 contact.update_presence(UNKNOWN_MUC_PRESENCE, notify=False)
    350 360
    351 361 
         def get_user_nicknames(self):
    352 362 
             client = app.get_client(self._account)
    353 
    -        manager = client.get_module('MUC').get_manager()
    354 
    -        return manager.get_joined_users(self._jid)
    363 
    +        return client.get_module('MUC').get_joined_users(self._jid)
    355 364
    356 365
    357 366 
     class GroupchatParticipant(CommonContact):
    ... ... @@ -363,7 +372,6 @@ def __init__(self, logger, jid, account):
    363 372 
             self._client = app.get_client(self._account)
    364 373
    365 374 
             self._presence = UNKNOWN_MUC_PRESENCE
    366 
    -        self._muc_manager = self._client.get_module('MUC').get_manager()
    367 375
    368 376 
         @property
    369 377 
         def is_pm_contact(self):

  • gajim/common/modules/discovery.py
    ... ... @@ -226,8 +226,7 @@ def disco_muc(self,
    226 226 
                     if not app.interface.avatar_exists(avatar_sha):
    227 227 
                         app.interface.save_avatar(avatar)
    228 228
    229 
    -                app.storage.cache.set_muc_avatar_sha(result.info.jid,
    230 
    -                                                     avatar_sha)
    229 
    +                app.storage.cache.set_muc(result.info.jid, 'avatar', avatar_sha)
    231 230 
                     app.interface.avatar_storage.invalidate_cache(result.info.jid)
    232 231
    233 232 
             self._con.get_module('VCardAvatars').muc_disco_info_update(result.info)

  • gajim/common/modules/muc.py
    ... ... @@ -35,10 +35,8 @@
    35 35 
     from gajim.common.const import MUCJoinedState
    36 36 
     from gajim.common.helpers import AdditionalDataDict
    37 37 
     from gajim.common.helpers import get_default_muc_config
    38 
    -from gajim.common.helpers import to_user_string
    39 38 
     from gajim.common.helpers import event_filter
    40 39 
     from gajim.common.helpers import get_group_chat_nick
    41 
    -from gajim.common.helpers import Observable
    42 40 
     from gajim.common.structs import MUCData
    43 41 
     from gajim.common.structs import MUCPresenceData
    44 42 
     from gajim.common.nec import NetworkEvent
    ... ... @@ -114,11 +112,12 @@ def __init__(self, con):
    114 112 
                 # ('signed-in', ged.GUI1, self._on_signed_in),
    115 113 
             ])
    116 114
    117 
    -        self._manager = MUCManager(self._account, self._log)
    118 115 
             self._rejoin_muc = set()
    119 116 
             self._join_timeouts = {}
    120 117 
             self._rejoin_timeouts = {}
    121 118 
             self._muc_service_jid = None
    119 
    +        self._joined_users = defaultdict(dict)
    120 
    +        self._mucs = {}
    122 121
    123 122 
         @property
    124 123 
         def supported(self):
    ... ... @@ -128,9 +127,6 @@ def supported(self):
    128 127 
         def service_jid(self):
    129 128 
             return self._muc_service_jid
    130 129
    131 
    -    def get_manager(self):
    132 
    -        return self._manager
    133 
    -
    134 130 
         def pass_disco(self, info):
    135 131 
             for identity in info.identities:
    136 132 
                 if identity.category != 'conference':
    ... ... @@ -142,6 +138,38 @@ def pass_disco(self, info):
    142 138 
                     self._muc_service_jid = info.jid
    143 139 
                     raise nbxmpp.NodeProcessed
    144 140
    141 
    +    def get_muc_data(self, room_jid):
    142 
    +        return self._mucs.get(room_jid)
    143 
    +
    144 
    +    def _get_mucs_with_state(self, states):
    145 
    +        return [muc for muc in self._mucs.values() if muc.state in states]
    146 
    +
    147 
    +    def _set_muc_state(self, room_jid, state):
    148 
    +        try:
    149 
    +            muc = self._mucs[room_jid]
    150 
    +        except KeyError:
    151 
    +            raise ValueError('set_muc_state() called '
    152 
    +                             'on unknown muc: %s' % room_jid)
    153 
    +
    154 
    +        if muc.state == state:
    155 
    +            return
    156 
    +
    157 
    +        self._log.info('Set MUC state: %s %s', room_jid, state)
    158 
    +
    159 
    +        muc.state = state
    160 
    +        contact = self._get_contact(room_jid, groupchat=True)
    161 
    +        contact.notify('state-changed')
    162 
    +
    163 
    +    def reset_state(self):
    164 
    +        for muc in self._mucs.values():
    165 
    +            self._joined_users.pop(muc.jid, None)
    166 
    +            self._set_muc_state(muc.jid, MUCJoinedState.NOT_JOINED)
    167 
    +            room = self._get_contact(muc.jid)
    168 
    +            room.set_not_joined()
    169 
    +            room.notify('room-left')
    170 
    +
    171 
    +        self._joined_users.clear()
    172 
    +
    145 173 
         def _create_muc_data(self, room_jid, nick, password, config):
    146 174 
             if not nick:
    147 175 
                 nick = get_group_chat_nick(self._account, room_jid)
    ... ... @@ -160,10 +188,11 @@ def join(self, jid, nick=None, password=None, config=None):
    160 188
    161 189 
             self._con.get_module('Contacts').add_contact(jid, groupchat=True)
    162 190
    163 
    -        muc_data = self._manager.get(jid)
    191 
    +        muc_data = self._mucs.get(jid)
    164 192 
             if muc_data is None:
    165 193 
                 muc_data = self._create_muc_data(jid, nick, password, config)
    166 
    -            self._manager.add(muc_data)
    194 
    +            self._mucs[jid] = muc_data
    195 
    +            self._push_muc_added_event(jid)
    167 196
    168 197 
             if not muc_data.state.is_not_joined:
    169 198 
                 self._log.warning('Can’t join MUC %s, state: %s',
    ... ... @@ -183,8 +212,15 @@ def create(self, muc_data):
    183 212 
             if not app.account_is_available(self._account):
    184 213 
                 return
    185 214
    186 
    -        self._manager.add(muc_data)
    215 
    +        self._mucs[muc_data.jid] = muc_data
    187 216 
             self._create(muc_data)
    217 
    +        self._push_muc_added_event(muc_data.jid)
    218 
    +
    219 
    +    def _push_muc_added_event(self, jid):
    220 
    +        app.nec.push_incoming_event(
    221 
    +            NetworkEvent('muc-added',
    222 
    +                         account=self._account,
    223 
    +                         jid=jid))
    188 224
    189 225 
         def _on_disco_result(self, task):
    190 226 
             try:
    ... ... @@ -196,7 +232,7 @@ def _on_disco_result(self, task):
    196 232 
                 room.notify('room-join-failed', error)
    197 233 
                 return
    198 234
    199 
    -        muc_data = self._manager.get(result.info.jid)
    235 
    +        muc_data = self._mucs.get(result.info.jid)
    200 236 
             if muc_data is None:
    201 237 
                 self._log.warning('MUC Data not found, join aborted')
    202 238 
                 return
    ... ... @@ -215,12 +251,12 @@ def _join(self, muc_data):
    215 251 
                 muc_x.setTagData('password', muc_data.password)
    216 252
    217 253 
             self._log.info('Join MUC: %s', muc_data.jid)
    218 
    -        self._manager.set_state(muc_data.jid, MUCJoinedState.JOINING)
    254 
    +        self._set_muc_state(muc_data.jid, MUCJoinedState.JOINING)
    219 255 
             self._con.send_stanza(presence)
    220 256
    221 257 
         def _rejoin(self, room_jid):
    222 
    -        muc_data = self._manager.get(room_jid)
    223 
    -        if muc_data.state == MUCJoinedState.NOT_JOINED:
    258 
    +        muc_data = self._mucs[room_jid]
    259 
    +        if muc_data.state.is_not_joined:
    224 260 
                 self._log.info('Rejoin %s', room_jid)
    225 261 
                 self._join(muc_data)
    226 262 
             return True
    ... ... @@ -234,7 +270,7 @@ def _create(self, muc_data):
    234 270 
             presence.setTag(Namespace.MUC + ' x')
    235 271
    236 272 
             self._log.info('Create MUC: %s', muc_data.jid)
    237 
    -        self._manager.set_state(muc_data.jid, MUCJoinedState.CREATING)
    273 
    +        self._set_muc_state(muc_data.jid, MUCJoinedState.CREATING)
    238 274 
             self._con.send_stanza(presence)
    239 275
    240 276 
         def leave(self, room_jid, reason=None):
    ... ... @@ -242,11 +278,11 @@ def leave(self, room_jid, reason=None):
    242 278
    243 279 
             self._con.get_module('Bookmarks').modify(room_jid, autojoin=False)
    244 280
    245 
    -        muc_data = self._manager.get(room_jid)
    281 
    +        muc_data = self._mucs.get(room_jid)
    246 282 
             if muc_data is None:
    247 283 
                 return
    248 284
    249 
    -        if muc_data.state == MUCJoinedState.NOT_JOINED:
    285 
    +        if muc_data.state.is_not_joined:
    250 286 
                 return
    251 287
    252 288 
             self._remove_join_timeout(room_jid)
    ... ... @@ -258,7 +294,7 @@ def leave(self, room_jid, reason=None):
    258 294 
                 status=reason,
    259 295 
                 caps=False)
    260 296
    261 
    -        self._manager.set_state(room_jid, MUCJoinedState.NOT_JOINED)
    297 
    +        self._set_muc_state(room_jid, MUCJoinedState.NOT_JOINED)
    262 298 
             room = self._get_contact(room_jid)
    263 299 
             room.set_not_joined()
    264 300 
             room.notify('room-left')
    ... ... @@ -279,7 +315,7 @@ def _on_room_config(self, task):
    279 315
    280 316 
             self._log.info('Configure room: %s', result.jid)
    281 317
    282 
    -        muc_data = self._manager.get(result.jid)
    318 
    +        muc_data = self._mucs[result.jid]
    283 319 
             self._apply_config(result.form, muc_data.config)
    284 320 
             self.set_config(result.jid,
    285 321 
                             result.form,
    ... ... @@ -333,7 +369,7 @@ def _on_disco_result_after_config(self, task):
    333 369 
                 return
    334 370
    335 371 
             jid = result.info.jid
    336 
    -        muc_data = self._manager.get(jid)
    372 
    +        muc_data = self._mucs[jid]
    337 373 
             self._room_join_complete(muc_data)
    338 374
    339 375 
             self._log.info('Configuration finished: %s', jid)
    ... ... @@ -342,8 +378,8 @@ def _on_disco_result_after_config(self, task):
    342 378 
             room.notify('room-config-finished')
    343 379
    344 380 
         def update_presence(self):
    345 
    -        mucs = self._manager.get_mucs_with_state([MUCJoinedState.JOINED,
    346 
    -                                                  MUCJoinedState.JOINING])
    381 
    +        mucs = self._get_mucs_with_state([MUCJoinedState.JOINED,
    382 
    +                                          MUCJoinedState.JOINING])
    347 383
    348 384 
             status, message, idle = self._con.get_presence_state()
    349 385 
             for muc_data in mucs:
    ... ... @@ -362,7 +398,7 @@ def change_nick(self, room_jid, new_nick):
    362 398
    363 399 
         def _on_error_presence(self, _con, stanza, properties):
    364 400 
             room_jid = properties.jid.bare
    365 
    -        muc_data = self._manager.get(room_jid)
    401 
    +        muc_data = self._mucs.get(room_jid)
    366 402 
             if muc_data is None:
    367 403 
                 return
    368 404
    ... ... @@ -383,25 +419,25 @@ def _on_error_presence(self, _con, stanza, properties):
    383 419
    384 420 
                 elif properties.error.condition == 'not-authorized':
    385 421 
                     self._remove_rejoin_timeout(room_jid)
    386 
    -                self._manager.set_state(room_jid, MUCJoinedState.NOT_JOINED)
    422 
    +                self._set_muc_state(room_jid, MUCJoinedState.NOT_JOINED)
    387 423 
                     room.notify('room-password-required', properties)
    388 424
    389 425 
                 else:
    390 
    -                self._manager.set_state(room_jid, MUCJoinedState.NOT_JOINED)
    426 
    +                self._set_muc_state(room_jid, MUCJoinedState.NOT_JOINED)
    391 427 
                     if room_jid not in self._rejoin_muc:
    392 428 
                         room.notify('room-join-failed', properties.error)
    393 429
    394 430 
             elif muc_data.state == MUCJoinedState.CREATING:
    395 
    -            self._manager.set_state(room_jid, MUCJoinedState.NOT_JOINED)
    431 
    +            self._set_muc_state(room_jid, MUCJoinedState.NOT_JOINED)
    396 432 
                 room.notify('room-creation-failed', properties)
    397 433
    398 434 
             elif muc_data.state == MUCJoinedState.CAPTCHA_REQUEST:
    399 
    -            self._manager.set_state(room_jid, MUCJoinedState.CAPTCHA_FAILED)
    400 
    -            self._manager.set_state(room_jid, MUCJoinedState.NOT_JOINED)
    435 
    +            self._set_muc_state(room_jid, MUCJoinedState.CAPTCHA_FAILED)
    436 
    +            self._set_muc_state(room_jid, MUCJoinedState.NOT_JOINED)
    401 437 
                 room.notify('room-captcha-error', properties.error)
    402 438
    403 439 
             elif muc_data.state == MUCJoinedState.CAPTCHA_FAILED:
    404 
    -            self._manager.set_state(room_jid, MUCJoinedState.NOT_JOINED)
    440 
    +            self._set_muc_state(room_jid, MUCJoinedState.NOT_JOINED)
    405 441
    406 442 
             else:
    407 443 
                 room.notify('room-presence-error', properties)
    ... ... @@ -411,19 +447,19 @@ def _on_muc_user_presence(self, _con, stanza, properties):
    411 447 
                 return
    412 448
    413 449 
             room_jid = str(properties.muc_jid)
    414 
    -        if room_jid not in self._manager:
    450 
    +        if room_jid not in self._mucs:
    415 451 
                 self._log.warning('Presence from unknown MUC')
    416 452 
                 self._log.warning(stanza)
    417 453 
                 return
    418 454
    419 
    -        muc_data = self._manager.get(room_jid)
    455 
    +        muc_data = self._mucs[room_jid]
    420 456 
             occupant = self._get_contact(properties.jid, groupchat=True)
    421 457 
             room = self._get_contact(properties.jid.bare)
    422 458
    423 459 
             if properties.is_muc_destroyed:
    424 460 
                 self._log.info('MUC destroyed: %s', room_jid)
    425 461 
                 self._remove_join_timeout(room_jid)
    426 
    -            self._manager.set_state(room_jid, MUCJoinedState.NOT_JOINED)
    462 
    +            self._set_muc_state(room_jid, MUCJoinedState.NOT_JOINED)
    427 463 
                 room.set_not_joined()
    428 464 
                 room.notify('destroyed', properties)
    429 465 
                 return
    ... ... @@ -444,16 +480,20 @@ def _on_muc_user_presence(self, _con, stanza, properties):
    444 480 
                 new_occupant = room.add_resource(properties.muc_user.nick)
    445 481 
                 new_occupant.set_presence(occupant.presence)
    446 482
    447 
    -            presence = self._manager.process_presence(properties)
    483 
    +            presence = self._process_user_presence(properties)
    448 484 
                 occupant.update_presence(presence, properties)
    449 485
    486 
    +            # new_nick = properties.muc_user.nick
    487 
    +            # nick = properties.muc_nickname
    488 
    +            # presence_dict = self._joined_users[properties.jid.bare]
    489 
    +            # presence_dict[new_nick] = presence_dict.pop(nick)
    450 490 
                 # self._manager.change_nickname
    451 491 
                 # TODO remove presence from manager
    452 492
    453 493 
                 room.notify('user-nickname-changed', occupant, properties)
    454 494 
                 return
    455 495
    456 
    -        is_joined = self._manager.is_joined(properties.jid)
    496 
    +        is_joined = self._is_user_joined(properties.jid)
    457 497 
             if not is_joined and properties.type.is_available:
    458 498 
                 if properties.is_muc_self_presence:
    459 499 
                     self._log.info('Self presence: %s', properties.jid)
    ... ... @@ -470,12 +510,12 @@ def _on_muc_user_presence(self, _con, stanza, properties):
    470 510
    471 511 
                     self._start_join_timeout(room_jid)
    472 512
    473 
    -            presence = self._manager.process_presence(properties)
    513 
    +            presence = self._process_user_presence(properties)
    474 514 
                 occupant.update_presence(presence, properties)
    475 515 
                 return
    476 516
    477 517 
             if properties.is_muc_self_presence and properties.is_kicked:
    478 
    -            self._manager.set_state(room_jid, MUCJoinedState.NOT_JOINED)
    518 
    +            self._set_muc_state(room_jid, MUCJoinedState.NOT_JOINED)
    479 519 
                 room.set_not_joined()
    480 520 
                 room.notify('kicked', properties)
    481 521 
                 status_codes = properties.muc_status_codes or []
    ... ... @@ -488,9 +528,28 @@ def _on_muc_user_presence(self, _con, stanza, properties):
    488 528 
                 # unavailable presence, because we left the MUC
    489 529 
                 return
    490 530
    491 
    -        presence = self._manager.process_presence(properties)
    531 
    +        presence = self._process_user_presence(properties)
    492 532 
             occupant.update_presence(presence, properties)
    493 533
    534 
    +    def _process_user_presence(self, properties):
    535 
    +        jid = properties.jid
    536 
    +        muc_presence = MUCPresenceData.from_presence(properties)
    537 
    +        if not muc_presence.available:
    538 
    +            self._joined_users[jid.bare].pop(jid.resource)
    539 
    +        else:
    540 
    +            self._joined_users[jid.bare][jid.resource] = muc_presence
    541 
    +        return muc_presence
    542 
    +
    543 
    +    def _is_user_joined(self, jid):
    544 
    +        try:
    545 
    +            self._joined_users[jid.bare][jid.resource]
    546 
    +        except KeyError:
    547 
    +            return False
    548 
    +        return True
    549 
    +
    550 
    +    def get_joined_users(self, jid):
    551 
    +        return list(self._joined_users[jid].keys())
    552 
    +
    494 553 
         def _start_rejoin_timeout(self, room_jid):
    495 554 
             self._remove_rejoin_timeout(room_jid)
    496 555 
             self._rejoin_muc.add(room_jid)
    ... ... @@ -568,7 +627,7 @@ def _on_subject_change(self, _con, _stanza, properties):
    568 627
    569 628 
             room_jid = properties.jid.bare
    570 629
    571 
    -        muc_data = self._manager.get(room_jid)
    630 
    +        muc_data = self._mucs.get(room_jid)
    572 631 
             if muc_data is None:
    573 632 
                 self._log.warning('No MUCData found for %s', room_jid)
    574 633 
                 return
    ... ... @@ -593,7 +652,7 @@ def _fake_subject_change(self, room_jid):
    593 652
    594 653 
         def _room_join_complete(self, muc_data):
    595 654 
             self._remove_join_timeout(muc_data.jid)
    596 
    -        self._manager.set_state(muc_data.jid, MUCJoinedState.JOINED)
    655 
    +        self._set_muc_state(muc_data.jid, MUCJoinedState.JOINED)
    597 656 
             self._remove_rejoin_timeout(muc_data.jid)
    598 657
    599 658 
             # We successfully joined a MUC, set add bookmark with autojoin
    ... ... @@ -626,7 +685,7 @@ def _on_captcha_challenge(self, _con, _stanza, properties):
    626 685 
                 self._log.warning('Ignore captcha challenge received from MAM')
    627 686 
                 raise nbxmpp.NodeProcessed
    628 687
    629 
    -        muc_data = self._manager.get(properties.jid)
    688 
    +        muc_data = self._mucs.get(properties.jid)
    630 689 
             if muc_data is None:
    631 690 
                 return
    632 691
    ... ... @@ -639,7 +698,7 @@ def _on_captcha_challenge(self, _con, _stanza, properties):
    639 698 
             store_bob_data(properties.captcha.bob_data)
    640 699 
             muc_data.captcha_id = properties.id
    641 700
    642 
    -        self._manager.set_state(properties.jid, MUCJoinedState.CAPTCHA_REQUEST)
    701 
    +        self._set_muc_state(properties.jid, MUCJoinedState.CAPTCHA_REQUEST)
    643 702 
             self._remove_rejoin_timeout(properties.jid)
    644 703
    645 704 
             room = self._get_contact(properties.jid.bare)
    ... ... @@ -648,7 +707,7 @@ def _on_captcha_challenge(self, _con, _stanza, properties):
    648 707 
             raise nbxmpp.NodeProcessed
    649 708
    650 709 
         def cancel_captcha(self, room_jid):
    651 
    -        muc_data = self._manager.get(room_jid)
    710 
    +        muc_data = self._mucs.get(room_jid)
    652 711 
             if muc_data is None:
    653 712 
                 return
    654 713
    ... ... @@ -656,11 +715,11 @@ def cancel_captcha(self, room_jid):
    656 715 
                 self._log.warning('No captcha message id available')
    657 716 
                 return
    658 717 
             self._nbxmpp('MUC').cancel_captcha(room_jid, muc_data.captcha_id)
    659 
    -        self._manager.set_state(room_jid, MUCJoinedState.CAPTCHA_FAILED)
    660 
    -        self._manager.set_state(room_jid, MUCJoinedState.NOT_JOINED)
    718 
    +        self._set_muc_state(room_jid, MUCJoinedState.CAPTCHA_FAILED)
    719 
    +        self._set_muc_state(room_jid, MUCJoinedState.NOT_JOINED)
    661 720
    662 721 
         def send_captcha(self, room_jid, form_node):
    663 
    -        self._manager.set_state(room_jid, MUCJoinedState.JOINING)
    722 
    +        self._set_muc_state(room_jid, MUCJoinedState.JOINING)
    664 723 
             self._nbxmpp('MUC').send_captcha(room_jid,
    665 724 
                                              form_node,
    666 725 
                                              callback=self._on_captcha_result)
    ... ... @@ -669,10 +728,10 @@ def _on_captcha_result(self, task):
    669 728 
             try:
    670 729 
                 task.finish()
    671 730 
             except StanzaError as error:
    672 
    -            muc_data = self._manager.get(error.jid)
    731 
    +            muc_data = self._mucs.get(error.jid)
    673 732 
                 if muc_data is None:
    674 733 
                     return
    675 
    -            self._manager.set_state(error.jid, MUCJoinedState.CAPTCHA_FAILED)
    734 
    +            self._set_muc_state(error.jid, MUCJoinedState.CAPTCHA_FAILED)
    676 735 
                 room = self._get_contact(error.jid)
    677 736 
                 room.notify('room-captcha-error', error)
    678 737
    ... ... @@ -744,7 +803,7 @@ def invite(self, room, jid, reason=None, continue_=False):
    744 803 
             if contact and contact.supports(Namespace.CONFERENCE):
    745 804 
                 type_ = InviteType.DIRECT
    746 805
    747 
    -        password = self._manager.get(room).password
    806 
    +        password = self._mucs[room].password
    748 807 
             self._log.info('Invite %s to %s', jid, room)
    749 808 
             return self._nbxmpp('MUC').invite(room, jid, reason, password,
    750 809 
                                               continue_, type_)
    ... ... @@ -758,81 +817,5 @@ def _on_account_disconnected(self, _event):
    758 817 
                 self._remove_join_timeout(room_jid)
    759 818
    760 819
    761 
    -class MUCManager(Observable):
    762 
    -    def __init__(self, account, logger):
    763 
    -        Observable.__init__(self)
    764 
    -        self._account = account
    765 
    -        self._log = logger
    766 
    -        self._mucs = {}
    767 
    -        self._joined_users = defaultdict(dict)
    768 
    -
    769 
    -    def process_presence(self, properties):
    770 
    -        jid = properties.jid
    771 
    -        muc_presence = MUCPresenceData.from_presence(properties)
    772 
    -        if not muc_presence.available:
    773 
    -            self._joined_users[jid.bare].pop(jid.resource)
    774 
    -        else:
    775 
    -            self._joined_users[jid.bare][jid.resource] = muc_presence
    776 
    -        return muc_presence
    777 
    -
    778 
    -    def change_nickname(self, properties):
    779 
    -        new_nick = properties.muc_user.nick
    780 
    -        nick = properties.muc_nickname
    781 
    -        presence_dict = self._joined_users[properties.jid.bare]
    782 
    -        presence_dict[new_nick] = presence_dict.pop(nick)
    783 
    -
    784 
    -    def is_joined(self, jid):
    785 
    -        try:
    786 
    -            self._joined_users[jid.bare][jid.resource]
    787 
    -        except KeyError:
    788 
    -            return False
    789 
    -        return True
    790 
    -
    791 
    -    def get_joined_users(self, jid):
    792 
    -        return list(self._joined_users[jid].keys())
    793 
    -
    794 
    -    def add(self, muc):
    795 
    -        self._mucs[muc.jid] = muc
    796 
    -        self.notify('muc-added', self._account, muc.jid)
    797 
    -
    798 
    -    def remove(self, muc):
    799 
    -        self._mucs.pop(muc.jid, None)
    800 
    -        self._joined_users.pop(muc.jid, None)
    801 
    -
    802 
    -    def get(self, room_jid):
    803 
    -        return self._mucs.get(room_jid)
    804 
    -
    805 
    -    def set_state(self, room_jid, state):
    806 
    -        muc = self._mucs.get(room_jid)
    807 
    -        if muc is not None:
    808 
    -            if muc.state == state:
    809 
    -                return
    810 
    -            self._log.info('Set MUC state: %s %s', room_jid, state)
    811 
    -
    812 
    -            muc.state = state
    813 
    -            self.notify('state-changed',
    814 
    -                        state,
    815 
    -                        qualifiers=(self._account, room_jid))
    816 
    -
    817 
    -    def get_joined_mucs(self):
    818 
    -        mucs = self._mucs.values()
    819 
    -        return [muc.jid for muc in mucs if muc.state == MUCJoinedState.JOINED]
    820 
    -
    821 
    -    def get_mucs_with_state(self, states):
    822 
    -        return [muc for muc in self._mucs.values() if muc.state in states]
    823 
    -
    824 
    -    def reset_state(self):
    825 
    -        client = app.get_client(self._account)
    826 
    -        for muc in self._mucs.values():
    827 
    -            self.set_state(muc.jid, MUCJoinedState.NOT_JOINED)
    828 
    -            self._joined_users.pop(muc.jid, None)
    829 
    -            room = client.get_module('Contacts').get_contact(muc.jid)
    830 
    -            room.set_not_joined()
    831 
    -            room.notify('room-left')
    832 
    -
    833 
    -    def __contains__(self, room_jid):
    834 
    -        return room_jid in self._mucs
    835 
    -
    836 
    -
    837 820 
     def get_instance(*args, **kwargs):
    838 821 
         return MUC(*args, **kwargs), 'MUC'

  • gajim/common/modules/presence.py
    ... ... @@ -72,7 +72,7 @@ def _presence_received(self, _con, stanza, properties):
    72 72 
                 # MUC occupant presences are already handled in MUC module
    73 73 
                 return
    74 74
    75 
    -        muc = self._con.get_module('MUC').get_manager().get(properties.jid)
    75 
    +        muc = self._con.get_module('MUC').get_muc_data(properties.jid)
    76 76 
             if muc is not None:
    77 77 
                 # Presence from the MUC itself, used for MUC avatar
    78 78 
                 # handled in VCardAvatars module

  • gajim/common/modules/vcard_avatars.py
    ... ... @@ -102,7 +102,7 @@ def _presence_received(self, _con, _stanza, properties):
    102 102
    103 103 
             else:
    104 104 
                 jid = properties.jid.new_as_bare()
    105 
    -            muc = self._con.get_module('MUC').get_manager().get(properties.jid)
    105 
    +            muc = self._con.get_module('MUC').get_muc_data(properties.jid)
    106 106 
                 self._process_update(jid,
    107 107 
                                      properties.avatar_state,
    108 108 
                                      properties.avatar_sha,

  • gajim/groupchat_control.py
    ... ... @@ -201,12 +201,6 @@ def __init__(self, parent_win, jid, muc_data, acct):
    201 201 
             self.xml.stack.show_all()
    202 202 
             self.xml.stack.set_visible_child_name('groupchat')
    203 203
    204 
    -        client = app.get_client(self.account)
    205 
    -        manager = client.get_module('MUC').get_manager()
    206 
    -        manager.connect('state-changed',
    207 
    -                        self._on_muc_state_changed,
    208 
    -                        qualifiers=(self.account, self.room_jid))
    209 
    -
    210 204 
             self.update_ui()
    211 205 
             self.widget.show_all()
    212 206
    ... ... @@ -221,6 +215,7 @@ def __init__(self, parent_win, jid, muc_data, acct):
    221 215
    222 216 
         def _connect_contact_signals(self):
    223 217 
             self.contact.multi_connect({
    218 
    +            'state-changed': self._on_muc_state_changed,
    224 219 
                 'avatar-update': self._on_avatar_update,
    225 220 
                 'user-joined': self._on_user_joined,
    226 221 
                 'user-left': self._on_user_left,
    ... ... @@ -244,7 +239,8 @@ def _connect_contact_signals(self):
    244 239 
                 'room-join-failed': self._on_room_join_failed,
    245 240 
             })
    246 241
    247 
    -    def _on_muc_state_changed(self, _muc_manager, _signal_name, state):
    242 
    +    def _on_muc_state_changed(self, _contact, _signal_name):
    243 
    +        state = self.contact.state
    248 244 
             if state == MUCJoinedState.JOINED:
    249 245 
                 self.roster.initial_draw()
    250 246
    ... ... @@ -273,8 +269,7 @@ def _on_muc_state_changed(self, _muc_manager, _signal_name, state):
    273 269 
         @property
    274 270 
         def _muc_data(self):
    275 271 
             client = app.get_client(self.account)
    276 
    -        manager = client.get_module('MUC').get_manager()
    277 
    -        return manager.get(self.room_jid)
    272 
    +        return client.get_module('MUC').get_muc_data(self.room_jid)
    278 273
    279 274 
         @property
    280 275 
         def _nick_completion(self):
    ... ... @@ -1380,8 +1375,6 @@ def shutdown(self, reason=None):
    1380 1375 
             app.settings.disconnect_signals(self)
    1381 1376 
             self.contact.disconnect(self)
    1382 1377
    1383 
    -        client = app.get_client(self.account)
    1384 
    -        client.get_module('MUC').get_manager().disconnect(self)
    1385 1378 
             # PluginSystem: removing GUI extension points connected with
    1386 1379 
             # GrouphatControl instance object
    1387 1380 
             app.plugin_manager.remove_gui_extension_point(

  • gajim/gui_interface.py
    ... ... @@ -1363,11 +1363,12 @@ def show_add_join_groupchat(self, account, jid, nickname=None):
    1363 1363
    1364 1364 
             app.window.add_group_chat(account, str(jid), select=True)
    1365 1365
    1366 
    -    def _on_muc_added(self, _muc_manger, _signal_name, account, jid):
    1367 
    -        if app.window.chat_exists(account, jid):
    1366 
    +    @staticmethod
    1367 
    +    def _on_muc_added(event):
    1368 
    +        if app.window.chat_exists(event.account, event.jid):
    1368 1369 
                 return
    1369 1370
    1370 
    -        app.window.add_group_chat(account, str(jid))
    1371 
    +        app.window.add_group_chat(event.account, str(event.jid))
    1371 1372
    1372 1373 
         def new_private_chat(self, gc_contact, account, session=None):
    1373 1374 
             conn = app.connections[account]
    ... ... @@ -1559,8 +1560,8 @@ def enable_account(self, account):
    1559 1560 
             app.plugin_manager.register_modules_for_account(
    1560 1561 
                 app.connections[account])
    1561 1562
    1562 
    -        muc_manager = app.connections[account].get_module('MUC').get_manager()
    1563 
    -        muc_manager.connect('muc-added', self._on_muc_added)
    1563 
    +        app.ged.register_event_handler(
    1564 
    +            'muc-added', ged.CORE, self._on_muc_added)
    1564 1565
    1565 1566 
             # update variables
    1566 1567 
             self.instances[account] = {
    ... ... @@ -2027,8 +2028,8 @@ def __init__(self):
    2027 2028 
                         app.settings.get_account_setting(account, 'active')):
    2028 2029 
                     client = Client(account)
    2029 2030 
                     app.connections[account] = client
    2030 
    -                muc_manager = client.get_module('MUC').get_manager()
    2031 
    -                muc_manager.connect('muc-added', self._on_muc_added)
    2031 
    +                app.ged.register_event_handler(
    2032 
    +                    'muc-added', ged.CORE, self._on_muc_added)
    2032 2033
    2033 2034 
             self.instances = {}
    2034 2035

  • gajim/privatechat_control.py
    ... ... @@ -46,7 +46,6 @@ class PrivateChatControl(ChatControl):
    46 46 
         def __init__(self, parent_win, jid, account):
    47 47 
             client = app.get_client(account)
    48 48 
             self._room_contact = client.get_module('Contacts').get_contact(jid.bare)
    49 
    -        self._manager = client.get_module('MUC').get_manager()
    50 49
    51 50 
             ChatControl.__init__(self, parent_win, jid, account, None)
    52 51
    ... ... @@ -73,7 +72,8 @@ def room_name(self):
    73 72 
             return self._room_contact.name
    74 73
    75 74 
         def get_our_nick(self):
    76 
    -        muc_data = self._manager.get(self._room_contact.jid)
    75 
    +        client = app.get_client(self.account)
    76 
    +        muc_data = client.get_module('MUC').get_muc_data(self._room_contact.jid)
    77 77 
             return muc_data.nick
    78 78
    79 79 
         def _on_user_nickname_changed(self,

    • —
    View it on GitLab.
    You're receiving this email because of your account on dev.gajim.org. If you'd like to receive fewer emails, you can adjust your notification settings.