@dataclass
 class _IrcConnection(BaseIrcConnection, ClientIdMixin):
-    hostname: InitVar[str]
-    port: InitVar[int]
+    hostname: InitVar[str]  # needed by BaseIrcConnection, but not desired as
+    port: InitVar[int]      # dataclass fields, only for __post_init__ call
 
     def __post_init__(self, hostname, port, **kwargs) -> None:
-        super().__init__(hostname=hostname, port=port, q_out=self.q_out,
+        super().__init__(hostname=hostname, port=port, _q_out=self._q_out,
                          **kwargs)
 
     def _make_recv_event(self, msg: IrcMessage) -> ClientEvent:
 
 
 @dataclass
-class ClientQueueMixin(QueueMixin):
+class ClientQueueMixin(QueueMixin, ClientIdMixin):
     'To QueueMixin adds _cput to extend ._put with client_id= setting.'
-    client_id_name = 'id_'
 
     def _cput(self, event_class, **kwargs) -> None:
-        self._put(event_class(client_id=getattr(self, self.client_id_name),
-                              **kwargs))
+        self._put(event_class(client_id=self.client_id, **kwargs))
 
     def _cputs(self, method_to_call: str, **kwargs) -> None:
         self._cput(ClientEvent.make_subtype(method_to_call, **kwargs))
     conn: Optional[_IrcConnection] = None
 
     def __init__(self, conn_setup: IrcConnSetup, **kwargs) -> None:
-        super().__init__(**kwargs)
         self._caps = _CapsManager(self.send)
         self.conn_setup = conn_setup
         if self.conn_setup.port <= 0:
             self.conn_setup.port = PORT_SSL
-        self.id_ = self.conn_setup.hostname
+        self.client_id = self.conn_setup.hostname
+        super().__init__(client_id=self.client_id, **kwargs)
         self.log = Logger(self._log)
         self.update_login(nick_confirmed=False,
                           nickname=self.conn_setup.nickname)
                             'not re-connecting since already connected')
                 self.conn = _IrcConnection(hostname=self.conn_setup.hostname,
                                            port=self.conn_setup.port,
-                                           q_out=self.q_out,
-                                           client_id=self.id_)
+                                           _q_out=self._q_out,
+                                           client_id=self.client_id)
                 self._cputs('on_connect')
             except IrcConnAbortException as e:
                 self.log.alert(str(e))
     payload: Client
 
     def affect(self, target: ClientsDb) -> None:
-        target[self.payload.id_] = self.payload
+        target[self.payload.client_id] = self.payload
 
         other.prefix = self._prefix
 
 
+@dataclass
 class _ClientWindow(Window, ClientQueueMixin):
-    client_id_name = 'client_id'
     prompt: _ClientPromptWidget
 
-    def __init__(self,
-                 parent: 'ClientTui',
-                 client_id: str,
-                 chat: str = '',
-                 **kwargs
-                 ) -> None:
+    def __init__(self, parent: 'ClientTui', chat: str = '', **kwargs) -> None:
         self._parent = parent
-        self.client_id = client_id
         self.chat = chat
         super().__init__(**kwargs)
 
         win_class = (_PrivmsgWindow if (chat and chat[0].isalpha())
                      else _ClientWindow)
         win = win_class(parent=self, idx=new_idx, term=self.term,
-                        q_out=self.q_out, client_id=client_id, chat=chat)
+                        _q_out=self._q_out, client_id=client_id, chat=chat)
         self.windows += [win]
         self._switch_window(new_idx)
         return win
             realname = nickname
         self._put(NewClientEvent(
             _ClientKnowingTui(
-                q_out=self.q_out,
+                _q_out=self._q_out,
                 conn_setup=IrcConnSetup(
                     hostname, port, nickname, realname, password))))