running shrink version. Needs a lot of cleanup

src/pyside6/gui_pyside6.py

@@ -1,64 +1,114 @@
 import sys
 from src import config
+from src.data import log
 from src.data import Message, compile_regex
 from src.pyside6.trade_widget import TradeCollection
 from PySide6 import QtCore
-from PySide6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QTabWidget
+from PySide6.QtWidgets import QApplication, QMainWindow, QTabWidget, QSizePolicy, QWidget
 import qdarktheme
 
 
+class ResizingTabWidget(QTabWidget):
+    def __init__(self, main_window):
+        super().__init__(main_window)
+        self.main_window = main_window
+        self.currentChanged.connect(self.updateGeometry)
+
+        self.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
+        self.setGeometry(0, 0, 20, 20)
+
+        self.trade_collections = {}
+        self.setTabsClosable(True)
+        self.tabCloseRequested.connect(self.del_tab)
+
+    def minimumSizeHint(self):
+        return self.sizeHint()
+
+    def sizeHint(self):
+        current = self.currentWidget()
+        if not current:
+            # print(f'Super SIZEHINT {super().sizeHint()}')
+            return super().sizeHint()
+        # print(f'SIZEHINT {current.sizeHint()}')
+        size = current.sizeHint()
+        size.setHeight(size.height() + self.tabBar().sizeHint().height())
+
+        return size
+
+    def updateSizes(self):
+        self.main_window.updateSizes()
+
+    def new_trade(self, message: Message):
+        if message.trade:
+            unique_item = message.trade.unique_item()
+            if unique_item in self.trade_collections:
+                self.trade_collections[unique_item].add_trade(message)
+            else:
+                collection = TradeCollection(message, self)
+                collection.setParent(self)
+                self.addTab(collection, message.trade.item)
+                self.trade_collections[message.trade.unique_item()] = collection
+
+                self.main_window.show()
+
+            self.main_window.updateSizes()
+
+    def del_tab(self, index: int):
+        collection = self.widget(index)
+        assert isinstance(collection, TradeCollection)
+        self.trade_collections[collection.unique_item].deleteLater()
+        del self.trade_collections[collection.unique_item]
+        if not self.trade_collections:
+            self.main_window.hide()
+
+    def del_collection(self, unique_item: str):
+        del self.trade_collections[unique_item]
+        if not self.trade_collections:
+            self.main_window.hide()
+
+
 class MainWindow(QMainWindow):
     def __init__(self):
         super().__init__()
 
-        self.setWindowFlag(QtCore.Qt.FramelessWindowHint)
+        # self.setWindowFlag(QtCore.Qt.FramelessWindowHint)
         self.setWindowFlag(QtCore.Qt.WindowStaysOnTopHint)
         self.setAttribute(QtCore.Qt.WA_TranslucentBackground)
 
-        self.trades = {}
-
         self.setWindowTitle("My App")
 
-        self.main_widget = QTabWidget(self)
+        self.tab_widget = ResizingTabWidget(self)
-        self.main_widget.setTabsClosable(True)
+        self.tab_widget.currentChanged.connect(self.updateSizes)
-        self.main_widget.tabCloseRequested.connect(self.del_tab)
+        # self.tab_widget = QTabWidget(self)
-        self.setCentralWidget(self.main_widget)
+        self.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
+        self.setGeometry(0, 0, 20, 20)
+
+        self.setCentralWidget(self.tab_widget)
+
+    def updateSizes(self):
+        for i in range(0, 10):
+            QApplication.processEvents()
+        log.debug(f'updateSizes {self.tab_widget.minimumSizeHint()}')
+        # self.resize(QtCore.QSize(200,200))
+        self.resize(self.tab_widget.minimumSizeHint())
+        QApplication.processEvents()
+        self.repaint()
+        # self.adjustSize()
 
     @QtCore.Slot()
     def new_trade(self, message: Message):
-        if message.trade:
+        self.tab_widget.new_trade(message)
-            unique_item = message.trade.unique_item()
-            if unique_item in self.trades:
-                self.trades[unique_item].add_trade(message)
-            else:
-                collection = TradeCollection(message, self)
-                collection.setParent(self.main_widget)
-                self.main_widget.addTab(collection, message.trade.item)
-                self.trades[message.trade.unique_item()] = collection
-                self.show()
-
-    def del_collection(self, unique_item: str):
-        del self.trades[unique_item]
-        if not self.trades:
-            self.hide()
-
-    def del_tab(self, index: int):
-        collection = self.main_widget.widget(index)
-        assert isinstance(collection, TradeCollection)
-        self.trades[collection.unique_item].deleteLater()
-        del self.trades[collection.unique_item]
-        if not self.trades:
-            self.hide()
 
 
 def start_app():
     app = QApplication(sys.argv)
     qdarktheme.setup_theme()
-    app.setStyle('Material')
+    # app.setStyle('Material')
 
     window = MainWindow()
     return app, window
 
+
 if __name__ == "__main__":
     conf = config.read_config(r'config.yaml')
     compile_regex(conf)
@@ -80,4 +130,3 @@ if __name__ == "__main__":
     window.new_trade(message2)
     window.new_trade(message3)
     app.exec()
-

src/pyside6/trade_widget.py

@@ -1,6 +1,8 @@
 from PySide6.QtWidgets import QPushButton, QHBoxLayout, QVBoxLayout, QWidget, QLabel, QSizePolicy
+from PySide6 import QtCore
 from src.data import Message
 from src import sendkeys
+from src.data import log
 
 
 class TradeWidget(QWidget):
@@ -14,7 +16,14 @@ class TradeWidget(QWidget):
         self.parent = parent
 
         self.main_layout = QHBoxLayout()
+        self.main_layout.setSpacing(0)
+        # self.main_layout.setMargin(0)
+        self.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
+        self.main_layout.setContentsMargins(0, 0, 0, 0)
+        self.setContentsMargins(0, 0, 0, 0)
+        self.setGeometry(0, 0, 0, 20)
         self.setLayout(self.main_layout)
+        assert message.trade
         self.label_user = QLabel(message.user)
         self.label_item = QLabel(message.trade.item)
         self.label_price = QLabel(f'{message.trade.amount} {message.trade.currency}')
@@ -23,16 +32,17 @@ class TradeWidget(QWidget):
                    ('trade', self.trade_callback),
                    ('ty', self.thank_callback),
                    ('wait', self.wait_callback),
-                   ('X', self.delete_callback) ]
+                   ('X', self.delete_callback)]
         for button in buttons:
             pb = QPushButton(button[0])
-            pb.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Minimum)
+            pb.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
+            pb.setContentsMargins(0, 0, 0, 0)
             pb.clicked.connect(button[1])
             self.main_layout.addWidget(pb)
 
+        self.main_layout.addWidget(self.label_item)
         self.main_layout.addWidget(self.label_price)
         self.main_layout.addWidget(self.label_user)
-        self.main_layout.addWidget(self.label_item)
 
     def inv_callback(self):
         sendkeys.invite(message=self.message)
@@ -60,16 +70,34 @@ class TradeCollection(QWidget):
     def __init__(self,
                  message: Message,
                  parent):
-        super(TradeCollection, self).__init__()
+        super(TradeCollection, self).__init__(parent)
         self.parent = parent
         assert message.trade
         self.unique_item = message.trade.unique_item()
+        self.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
+        self.setGeometry(0, 0, 20, 20)
         self.main_layout = QVBoxLayout()
+        self.main_layout.setSpacing(0)
+        self.main_layout.setContentsMargins(0, 0, 0, 0)
+        self.setContentsMargins(0, 0, 0, 0)
         self.setLayout(self.main_layout)
         trade = TradeWidget(message, self)
         self.main_layout.addWidget(trade)
         self.trades = {message.unique_trade(): trade}
 
+    def childEvent(self, event: QtCore.QChildEvent) -> None:
+        if event.removed():
+            log.debug('Child removed')
+            self.parent.updateSizes()
+        if event.added():
+            log.debug('Child added')
+        return super().childEvent(event)
+
+    def resizeEvent(self, event):
+        # self.resized.emit()
+        log.debug('resizeEvent')
+        return super(TradeCollection, self).resizeEvent(event)
+
     def add_trade(self, message: Message) -> None:
         assert message.trade
         if message.unique_trade() in self.trades: