cfclient 2017.4__py3-none-any.whl → 2025.12.1__py3-none-any.whl

cfclient/ui/tabs/GpsTab.py

@@ -7,7 +7,7 @@
 #  +------+    / /_/ / / /_/ /__/ /  / /_/ / / /_/  __/
 #   ||  ||    /_____/_/\__/\___/_/   \__,_/ /___/\___/
 #
-#  Copyright (C) 2011-2013 Bitcraze AB
+#  Copyright (C) 2011-2023 Bitcraze AB
 #
 #  Crazyflie Nano Quadcopter Client
 #
@@ -31,15 +31,15 @@ pre-configured.
 import logging
 
 import cfclient
-from PyQt5.QtCore import pyqtSignal
-from PyQt5.QtWidgets import QMessageBox
-from cfclient.ui.tab import Tab
+from PyQt6.QtCore import pyqtSignal
+from PyQt6.QtWidgets import QMessageBox
+from cfclient.ui.tab_toolbox import TabToolbox
 from cflib.crazyflie.log import LogConfig
-from PyQt5 import QtCore
-from PyQt5 import QtGui
-from PyQt5 import QtNetwork
-from PyQt5 import QtWebKit
-from PyQt5 import uic
+from PyQt6 import QtCore
+from PyQt6 import QtGui
+from PyQt6 import QtNetwork
+from PyQt6 import QtWebKit
+from PyQt6 import uic
 
 __author__ = 'Bitcraze AB'
 __all__ = ['GpsTab']
@@ -50,7 +50,7 @@ gps_tab_class = uic.loadUiType(cfclient.module_path +
                                "/ui/tabs/gpsTab.ui")[0]
 
 
-class GpsTab(Tab, gps_tab_class):
+class GpsTab(TabToolbox, gps_tab_class):
     """Tab for plotting logging data"""
 
     _log_data_signal = pyqtSignal(int, object, object)
@@ -60,15 +60,9 @@ class GpsTab(Tab, gps_tab_class):
     _connected_signal = pyqtSignal(str)
     _console_signal = pyqtSignal(str)
 
-    def __init__(self, tabWidget, helper, *args):
-        super(GpsTab, self).__init__(*args)
+    def __init__(self, helper):
+        super(GpsTab, self).__init__(helper, 'GPS')
         self.setupUi(self)
-
-        self.tabName = "GPS"
-        self.menuName = "GPS"
-
-        self.tabWidget = tabWidget
-        self.helper = helper
         self._cf = helper.cf
 
         view = self.view = QtWebKit.QWebView()
@@ -95,9 +89,9 @@ class GpsTab(Tab, gps_tab_class):
         self._disconnected_signal.connect(self._disconnected)
 
         # Connect the callbacks from the Crazyflie API
-        self.helper.cf.disconnected.add_callback(
+        self._helper.cf.disconnected.add_callback(
             self._disconnected_signal.emit)
-        self.helper.cf.connected.add_callback(
+        self._helper.cf.connected.add_callback(
             self._connected_signal.emit)
 
         self._max_speed = 0.0

cfclient/ui/tabs/LEDRingTab.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#     ||          ____  _ __
+#  +------+      / __ )(_) /_______________ _____  ___
+#  | 0xBC |     / __  / / __/ ___/ ___/ __ `/_  / / _ \
+#  +------+    / /_/ / / /_/ /__/ /  / /_/ / / /_/  __/
+#   ||  ||    /_____/_/\__/\___/_/   \__,_/ /___/\___/
+#
+#  Copyright (C) 2011-2025 Bitcraze AB
+#
+#  Crazyflie Nano Quadcopter Client
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+#  02110-1301, USA.
+
+"""
+Basic tab to be able to set (and test) colors in the LED-ring.
+"""
+
+import logging
+
+from PyQt6 import QtGui, uic
+from PyQt6.QtCore import pyqtSignal
+from PyQt6 import QtWidgets
+
+import cfclient
+from cfclient.ui.tab_toolbox import TabToolbox
+
+from cflib.crazyflie.mem import MemoryElement
+
+__author__ = 'Bitcraze AB'
+__all__ = ['LEDRingTab']
+
+logger = logging.getLogger(__name__)
+
+led_ring_tab_class = uic.loadUiType(cfclient.module_path + "/ui/tabs/ledRingTab.ui")[0]
+
+
+class LEDRingTab(TabToolbox, led_ring_tab_class):
+    """Tab for plotting logging data"""
+
+    _connected_signal = pyqtSignal(str)
+    _disconnected_signal = pyqtSignal(str)
+
+    def __init__(self, helper):
+        super(LEDRingTab, self).__init__(helper, 'LED Ring')
+        self.setupUi(self)
+
+        # LED-ring effect dropdown and headlight checkbox
+        self._ledring_nbr_effects = 0
+
+        # Connect the headlight checkbox
+        self._led_ring_headlight.clicked.connect(
+            lambda enabled: self._helper.cf.param.set_value("ring.headlightEnable", int(enabled)))
+
+        # Update headlight when param changes
+        self._helper.cf.param.add_update_callback(
+            group="ring", name="headlightEnable",
+            cb=lambda name, checked: self._led_ring_headlight.setChecked(bool(int(checked))))
+
+        # Update LED-ring effect when param changes
+        self._helper.cf.param.add_update_callback(
+            group="ring", name="effect",
+            cb=self._ring_effect_updated)
+
+        # Populate dropdown when all params are updated
+        self._helper.cf.param.all_updated.add_callback(self._ring_populate_dropdown)
+
+        # Always wrap callbacks from Crazyflie API though QT Signal/Slots
+        # to avoid manipulating the UI when rendering it
+        self._connected_signal.connect(self._connected)
+        self._disconnected_signal.connect(self._disconnected)
+
+        # Connect the Crazyflie API callbacks to the signals
+        self._helper.cf.connected.add_callback(
+            self._connected_signal.emit)
+
+        self._helper.cf.disconnected.add_callback(
+            self._disconnected_signal.emit)
+
+        self._btns = [self._u1,
+                      self._u2,
+                      self._u3,
+                      self._u4,
+                      self._u5,
+                      self._u6,
+                      self._u7,
+                      self._u8,
+                      self._u9,
+                      self._u10,
+                      self._u11,
+                      self._u12]
+
+        self._intensity = self._intensity_slider.value()
+
+        self._u1.clicked.connect(lambda: self._select(0))
+        self._u2.clicked.connect(lambda: self._select(1))
+        self._u3.clicked.connect(lambda: self._select(2))
+        self._u4.clicked.connect(lambda: self._select(3))
+        self._u5.clicked.connect(lambda: self._select(4))
+        self._u6.clicked.connect(lambda: self._select(5))
+        self._u7.clicked.connect(lambda: self._select(6))
+        self._u8.clicked.connect(lambda: self._select(7))
+        self._u9.clicked.connect(lambda: self._select(8))
+        self._u10.clicked.connect(lambda: self._select(9))
+        self._u11.clicked.connect(lambda: self._select(10))
+        self._u12.clicked.connect(lambda: self._select(11))
+
+        self._mem = None
+
+        self._intensity_slider.valueChanged.connect(self._intensity_change)
+        self._intensity_slider.valueChanged.connect(
+            self._intensity_spin.setValue)
+        self._intensity_spin.valueChanged.connect(
+            self._intensity_slider.setValue)
+
+        self._helper.inputDeviceReader.alt1_updated.add_callback(self.alt1_updated)
+        self._helper.inputDeviceReader.alt2_updated.add_callback(self.alt2_updated)
+
+        self._led_ring_effect.setEnabled(False)
+        self._led_ring_headlight.setEnabled(False)
+
+    def _select(self, nbr):
+        col = QtGui.QColor()
+
+        if self._mem:
+            led = self._mem.leds[nbr]
+            col = QtGui.QColor.fromRgb(led.r, led.g, led.b)
+
+        col = QtWidgets.QColorDialog.getColor(col)
+
+        if col.isValid() and self._mem:
+            r, g, b = col.red(), col.green(), col.blue()
+            self._mem.leds[nbr].set(r=r, g=g, b=b)
+
+            brightness = 0.299 * r + 0.587 * g + 0.114 * b
+            text_color = "white" if brightness < 128 else "black"
+
+            self.sender().setStyleSheet(
+                f"background-color: rgb({r}, {g}, {b}); color: {text_color};"
+            )
+
+            self._write_led_output()
+
+    def _intensity_change(self, value):
+        self._intensity = value
+        self._write_led_output()
+
+    def _write_led_output(self):
+        if self._mem:
+            for led in self._mem.leds:
+                led.intensity = self._intensity
+            self._mem.write_data(self._led_write_done)
+        else:
+            logger.info("No LED-ring memory found!")
+
+    def _led_write_done(self, mem, addr):
+        logger.info("LED write done callback")
+
+    def _connected(self, link_uri):
+        """Callback when the Crazyflie has been connected"""
+        mems = self._helper.cf.mem.get_mems(MemoryElement.TYPE_DRIVER_LED)
+        if len(mems) > 0:
+            self._mem = mems[0]
+            logger.info(self._mem)
+
+        if self._mem:
+            for btn in self._btns:
+                btn.setEnabled(True)
+                btn.setStyleSheet("background-color: black; color: white")
+                self._intensity_slider.setEnabled(True)
+                self._intensity_spin.setEnabled(True)
+
+        self._led_ring_effect.setEnabled(True)
+        self._led_ring_headlight.setEnabled(True)
+
+    def _disconnected(self, link_uri):
+        """Callback for when the Crazyflie has been disconnected"""
+        for btn in self._btns:
+            btn.setEnabled(False)
+            btn.setStyleSheet("background-color: none")
+            self._intensity_slider.setEnabled(False)
+            self._intensity_spin.setEnabled(False)
+            self._intensity_slider.setValue(100)
+
+        self._led_ring_effect.setEnabled(False)
+        self._led_ring_headlight.setEnabled(False)
+
+    def _ring_populate_dropdown(self):
+        try:
+            nbr = int(self._helper.cf.param.values["ring"]["neffect"])
+            current = int(self._helper.cf.param.values["ring"]["effect"])
+        except KeyError:
+            return
+
+        self._ring_effect = current
+        self._ledring_nbr_effects = nbr
+
+        hardcoded_names = {
+            0: "Off",
+            1: "White spinner",
+            2: "Color spinner",
+            3: "Tilt effect",
+            4: "Brightness effect",
+            5: "Color spinner 2",
+            6: "Double spinner",
+            7: "Solid color effect",
+            8: "Factory test",
+            9: "Battery status",
+            10: "Boat lights",
+            11: "Alert",
+            12: "Gravity",
+            13: "LED tab",
+            14: "Color fader",
+            15: "Link quality",
+            16: "Location server status",
+            17: "Sequencer",
+            18: "Lighthouse quality",
+        }
+
+        self._led_ring_effect.clear()
+        for i in range(nbr + 1):
+            name = "{}: ".format(i)
+            name += hardcoded_names.get(i, "N/A")
+            self._led_ring_effect.addItem(name, i)
+
+        self._led_ring_effect.currentIndexChanged.connect(self._ring_effect_changed)
+        self._led_ring_effect.setCurrentIndex(current)
+        self._led_ring_effect.setEnabled(int(self._helper.cf.param.values["deck"]["bcLedRing"]) == 1)
+        self._led_ring_headlight.setEnabled(int(self._helper.cf.param.values["deck"]["bcLedRing"]) == 1)
+
+        try:
+            self._helper.cf.param.set_value("ring.effect", "13")
+            self._led_ring_effect.setCurrentIndex(13)
+            self._ring_effect = 13
+            logger.info("Initialized LED ring to 'LED tab' mode (effect 13).")
+        except Exception as e:
+            logger.warning(f"Could not set LED tab effect on connect: {e}")
+
+    def _ring_effect_changed(self, index):
+        self._ring_effect = index
+        if index > -1:
+            i = self._led_ring_effect.itemData(index)
+            if i != int(self._helper.cf.param.values["ring"]["effect"]):
+                self._helper.cf.param.set_value("ring.effect", str(i))
+
+            if i == 13:
+                self._intensity_slider.setEnabled(True)
+                self._intensity_spin.setEnabled(True)
+            else:
+                self._intensity_slider.setEnabled(False)
+                self._intensity_spin.setEnabled(False)
+
+    def _ring_effect_updated(self, name, value):
+        if self._helper.cf.param.is_updated:
+            self._led_ring_effect.setCurrentIndex(int(value))
+
+    def alt1_updated(self, state):
+        if state:
+            new_index = (self._ring_effect+1) % (self._ledring_nbr_effects+1)
+            self._helper.cf.param.set_value("ring.effect", str(new_index))
+
+    def alt2_updated(self, state):
+        self._helper.cf.param.set_value("ring.headlightEnable", str(state))

cfclient/ui/tabs/LogBlockDebugTab.py

@@ -7,7 +7,7 @@
 #  +------+    / /_/ / / /_/ /__/ /  / /_/ / / /_/  __/
 #   ||  ||    /_____/_/\__/\___/_/   \__,_/ /___/\___/
 #
-#  Copyright (C) 2013 Bitcraze AB
+#  Copyright (C) 2013-2023 Bitcraze AB
 #
 #  Crazyflie Nano Quadcopter Client
 #
@@ -30,20 +30,19 @@ Shows all the parameters available in the Crazyflie and also gives the ability
 to edit them.
 """
 
-from PyQt5 import QtCore, QtWidgets, uic
-from PyQt5.QtCore import Qt, pyqtSignal
+from PyQt6 import QtWidgets, uic
+from PyQt6.QtCore import Qt, pyqtSignal
 
 import cfclient
-from cfclient.ui.tab import Tab
+from cfclient.ui.tab_toolbox import TabToolbox
 
 __author__ = 'Bitcraze AB'
 __all__ = ['LogBlockDebugTab']
 
-logblock_tab_class = uic.loadUiType(cfclient.module_path +
-                                    "/ui/tabs/logBlockDebugTab.ui")[0]
+logblock_tab_class = uic.loadUiType(cfclient.module_path + "/ui/tabs/logBlockDebugTab.ui")[0]
 
 
-class LogBlockDebugTab(Tab, logblock_tab_class):
+class LogBlockDebugTab(TabToolbox, logblock_tab_class):
     """
     Used to show debug-information about log status.
     """
@@ -51,16 +50,10 @@ class LogBlockDebugTab(Tab, logblock_tab_class):
     _blocks_updated_signal = pyqtSignal(object, bool)
     _disconnected_signal = pyqtSignal(str)
 
-    def __init__(self, tabWidget, helper, *args):
-        super(LogBlockDebugTab, self).__init__(*args)
+    def __init__(self, helper):
+        super(LogBlockDebugTab, self).__init__(helper, 'Log Blocks Debugging')
         self.setupUi(self)
 
-        self.tabName = "Log Blocks Debugging"
-        self.menuName = "Log Blocks Debugging"
-
-        self._helper = helper
-        self.tabWidget = tabWidget
-
         self._helper.cf.log.block_added_cb.add_callback(self._block_added)
         self._disconnected_signal.connect(self._disconnected)
         self._helper.cf.disconnected.add_callback(
@@ -70,7 +63,7 @@ class LogBlockDebugTab(Tab, logblock_tab_class):
         self._block_tree.setHeaderLabels(
             ['Id', 'Name', 'Period (ms)', 'Added', 'Started', 'Error',
              'Contents'])
-        self._block_tree.sortItems(0, QtCore.Qt.AscendingOrder)
+        self._block_tree.sortItems(0, Qt.SortOrder.AscendingOrder)
 
     def _block_added(self, block):
         """Callback when a new logblock has been created"""
@@ -82,19 +75,19 @@ class LogBlockDebugTab(Tab, logblock_tab_class):
         self._block_tree.clear()
         for block in self._helper.cf.log.log_blocks:
             item = QtWidgets.QTreeWidgetItem()
-            item.setFlags(Qt.ItemIsEnabled |
-                          Qt.ItemIsSelectable)
-            item.setData(0, Qt.DisplayRole, block.id)
-            item.setData(1, Qt.EditRole, block.name)
-            item.setData(2, Qt.DisplayRole, (block.period_in_ms))
-            item.setData(3, Qt.DisplayRole, block.added)
-            item.setData(4, Qt.EditRole, block.started)
-            item.setData(5, Qt.EditRole, block.err_no)
+            item.setFlags(Qt.ItemFlag.ItemIsEnabled |
+                          Qt.ItemFlag.ItemIsSelectable)
+            item.setData(0, Qt.ItemDataRole.DisplayRole, block.id)
+            item.setData(1, Qt.ItemDataRole.EditRole, block.name)
+            item.setData(2, Qt.ItemDataRole.DisplayRole, (block.period_in_ms))
+            item.setData(3, Qt.ItemDataRole.DisplayRole, block.added)
+            item.setData(4, Qt.ItemDataRole.EditRole, block.started)
+            item.setData(5, Qt.ItemDataRole.EditRole, block.err_no)
             for var in block.variables:
                 subItem = QtWidgets.QTreeWidgetItem()
-                subItem.setFlags(Qt.ItemIsEnabled |
-                                 Qt.ItemIsSelectable)
-                subItem.setData(6, Qt.EditRole, var.name)
+                subItem.setFlags(Qt.ItemFlag.ItemIsEnabled |
+                                 Qt.ItemFlag.ItemIsSelectable)
+                subItem.setData(6, Qt.ItemDataRole.EditRole, var.name)
                 item.addChild(subItem)
 
             self._block_tree.addTopLevelItem(item)

cfclient/ui/tabs/LogBlockTab.py

@@ -7,7 +7,7 @@
 #  +------+    / /_/ / / /_/ /__/ /  / /_/ / / /_/  __/
 #   ||  ||    /_____/_/\__/\___/_/   \__,_/ /___/\___/
 #
-#  Copyright (C) 2013 Bitcraze AB
+#  Copyright (C) 2013-2023 Bitcraze AB
 #
 #  Crazyflie Nano Quadcopter Client
 #
@@ -31,25 +31,24 @@ This tab shows all log blocks that are registered and can be used to start the
 logging and also to write the logging data to file.
 """
 
-from PyQt5 import uic
-from PyQt5.QtCore import Qt, pyqtSignal
+from PyQt6 import uic
+from PyQt6.QtCore import Qt, pyqtSignal
 
 import cfclient
-from cfclient.ui.tab import Tab
+from cfclient.ui.tab_toolbox import TabToolbox
 
 import logging
 
-from PyQt5.QtWidgets import QApplication, QStyledItemDelegate
-from PyQt5.QtWidgets import QAbstractItemView, QStyleOptionButton, QStyle
-from PyQt5.QtCore import QAbstractItemModel, QModelIndex
+from PyQt6.QtWidgets import QApplication, QStyledItemDelegate
+from PyQt6.QtWidgets import QAbstractItemView, QStyleOptionButton, QStyle
+from PyQt6.QtCore import QAbstractItemModel, QModelIndex
 
 from cfclient.utils.logdatawriter import LogWriter
 
 __author__ = 'Bitcraze AB'
 __all__ = ['LogBlockTab']
 
-logblock_tab_class = uic.loadUiType(
-    cfclient.module_path + "/ui/tabs/logBlockTab.ui")[0]
+logblock_tab_class = uic.loadUiType(cfclient.module_path + "/ui/tabs/logBlockTab.ui")[0]
 
 logger = logging.getLogger(__name__)
 
@@ -176,6 +175,7 @@ class LogBlockModel(QAbstractItemModel):
     def add_block(self, block, connected_ts):
         self._nodes.append(LogBlockItem(block, self, connected_ts))
         self.layoutChanged.emit()
+        self._nodes.sort(key=lambda conf: conf.name.lower())
 
     def refresh(self):
         """Force a refresh of the view though the model"""
@@ -220,7 +220,7 @@ class LogBlockModel(QAbstractItemModel):
 
     def headerData(self, section, orientation, role):
         """Re-implemented method to get the headers"""
-        if role == Qt.DisplayRole:
+        if role == Qt.ItemDataRole.DisplayRole:
             return self._column_headers[section]
 
     def rowCount(self, parent):
@@ -250,20 +250,20 @@ class LogBlockModel(QAbstractItemModel):
         node = index.internalPointer()
         parent = node.parent
         if parent:
-            if role == Qt.DisplayRole and index.column() == 5:
+            if role == Qt.ItemDataRole.DisplayRole and index.column() == 5:
                 return node.name
-        elif not parent and role == Qt.DisplayRole and index.column() == 5:
+        elif not parent and role == Qt.ItemDataRole.DisplayRole and index.column() == 5:
             return node.var_list()
-        elif not parent and role == Qt.DisplayRole:
+        elif not parent and role == Qt.ItemDataRole.DisplayRole:
             if index.column() == 0:
                 return node.id
             if index.column() == 1:
                 return node.name
             if index.column() == 2:
                 return str(node.period)
-        if role == Qt.TextAlignmentRole and \
+        if role == Qt.ItemDataRole.TextAlignmentRole and \
                 (index.column() == 4 or index.column() == 3):
-            return Qt.AlignHCenter | Qt.AlignVCenter
+            return Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter
 
         return None
 
@@ -286,31 +286,37 @@ class CheckboxDelegate(QStyledItemDelegate):
         col = index.column()
         if not item.parent and (col == 3 or col == 4):
             s = QStyleOptionButton()
-            checkbox_rect = QApplication.style(). \
-                subElementRect(QStyle.SE_CheckBoxIndicator, option)
+            checkbox_rect = QApplication.style().subElementRect(QStyle.SubElement.SE_CheckBoxIndicator, option)
             s.rect = option.rect
-            center_offset = s.rect.width() / 2 - checkbox_rect.width() / 2
+            center_offset = int(s.rect.width() / 2 - checkbox_rect.width() / 2)
             s.rect.adjust(center_offset, 0, 0, 0)
 
             if col == 3:
                 if not item.doing_transaction():
-                    s.state = QStyle.State_Enabled
+                    s.state = QStyle.StateFlag.State_Enabled
                 if item.logging_started():
-                    s.state |= QStyle.State_On
+                    s.state |= QStyle.StateFlag.State_On
 
             if col == 4:
-                s.state = QStyle.State_Enabled
+                s.state = QStyle.StateFlag.State_Enabled
                 if item.writing_to_file():
-                    s.state |= QStyle.State_On
-
-            QApplication.style().drawControl(
-                QStyle.CE_CheckBox, s, painter)
+                    s.state |= QStyle.StateFlag.State_On
 
+            self._paint_checkbox(s, painter)
         else:
             super(CheckboxDelegate, self).paint(painter, option, index)
 
+    def _paint_checkbox(self, style, painter):
+        QApplication.style().drawControl(QStyle.ControlElement.CE_CheckBox, style, painter)
+
+    def _paint_checkbox_osx_workaround(self, style, painter):
+        painter.save()
+        painter.translate(style.rect.topLeft())
+        QApplication.style().drawControl(QStyle.ControlElement.CE_CheckBox, style, painter)
+        painter.restore()
+
 
-class LogBlockTab(Tab, logblock_tab_class):
+class LogBlockTab(TabToolbox, logblock_tab_class):
     """
     Used to show debug-information about logblock status.
     """
@@ -318,17 +324,11 @@ class LogBlockTab(Tab, logblock_tab_class):
     _blocks_updated_signal = pyqtSignal(bool)
     _disconnected_signal = pyqtSignal(str)
 
-    def __init__(self, tabWidget, helper, *args):
+    def __init__(self, helper):
         """Initialize the tab"""
-        super(LogBlockTab, self).__init__(*args)
+        super(LogBlockTab, self).__init__(helper, 'Log Blocks')
         self.setupUi(self)
 
-        self.tabName = "Log Blocks"
-        self.menuName = "Log Blocks"
-
-        self._helper = helper
-        self.tabWidget = tabWidget
-
         self._helper.cf.log.block_added_cb.add_callback(self._block_added)
         self._disconnected_signal.connect(self._disconnected)
         self._helper.cf.disconnected.add_callback(
@@ -338,7 +338,7 @@ class LogBlockTab(Tab, logblock_tab_class):
         self._block_tree.setModel(self._model)
         self._block_tree.clicked.connect(self._model.clicked)
         self._block_tree.setItemDelegate(CheckboxDelegate())
-        self._block_tree.setSelectionMode(QAbstractItemView.NoSelection)
+        self._block_tree.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
 
     def _block_added(self, block):
         """Callback from logging layer when a new block is added"""

cfclient/ui/tabs/LogClientTab.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#     ||          ____  _ __
+#  +------+      / __ )(_) /_______________ _____  ___
+#  | 0xBC |     / __  / / __/ ___/ ___/ __ `/_  / / _ \
+#  +------+    / /_/ / / /_/ /__/ /  / /_/ / / /_/  __/
+#   ||  ||    /_____/_/\__/\___/_/   \__,_/ /___/\___/
+#
+#  Copyright (C) 2011-2023 Bitcraze AB
+#
+#  Crazyflie Nano Quadcopter Client
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+
+#  You should have received a copy of the GNU General Public License along with
+#  this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+"""
+Shows information from the Python logging framework
+"""
+
+import logging
+
+from PyQt6 import uic
+from PyQt6.QtCore import pyqtSignal
+
+import cfclient
+from cfclient.ui.tab_toolbox import TabToolbox
+
+__author__ = 'Bitcraze AB'
+__all__ = ['LogClientTab']
+
+logger = logging.getLogger(__name__)
+
+log_client_tab_class = uic.loadUiType(cfclient.module_path + "/ui/tabs/logClientTab.ui")[0]
+
+
+class LogHandler(logging.StreamHandler):
+    def __init__(self, signal):
+        logging.StreamHandler.__init__(self)
+        self._signal = signal
+
+    def emit(self, record):
+        fmt = '%(levelname)s:%(name)s:%(message)s'
+        formatter = logging.Formatter(fmt)
+        #
+        # Calling .emit() on the signal will make the callback
+        # we registered in LogClientTab run.
+        #
+        self._signal.emit(formatter.format(record))
+
+
+class LogClientTab(TabToolbox, log_client_tab_class):
+    """
+    A tab for showing client logging information, such
+    as USB Gamepad connections or scan feedback.
+    """
+    _update = pyqtSignal(str)
+
+    def __init__(self, helper):
+        super(LogClientTab, self).__init__(helper, 'Log Client')
+        self.setupUi(self)
+
+        self._update.connect(self.printText)
+        self._clearButton.clicked.connect(self.clear)
+
+        cflogger = logging.getLogger(None)
+        cflogger.addHandler(LogHandler(self._update))
+
+    def printText(self, text):
+        logger.debug("[%s]", text)
+        self.syslog.insertPlainText(text + '\n')
+
+    def clear(self):
+        self.syslog.clear()