boris-behav-obs 8.9.16__py3-none-any.whl → 9.7.6__py3-none-any.whl

boris/dialog.py

@@ -1,7 +1,7 @@
 """
 BORIS
 Behavioral Observation Research Interactive Software
-Copyright 2012-2023 Olivier Friard
+Copyright 2012-2025 Olivier Friard
 
 This file is part of BORIS.
 
@@ -20,16 +20,18 @@ This file is part of BORIS.
 
 """
 
+import datetime as dt
+from decimal import Decimal as dec
 import logging
-import sys
+import math
 import pathlib as pl
-import traceback
 import platform
-import datetime as dt
-from decimal import Decimal as dec
+import sys
+import traceback
+from typing import Union
 
-from PyQt5.QtCore import Qt, pyqtSignal, QT_VERSION_STR, PYQT_VERSION_STR
-from PyQt5.QtWidgets import (
+from PySide6.QtCore import Qt, Signal, qVersion, QRect, QTime, QDateTime, QSize
+from PySide6.QtWidgets import (
     QApplication,
     QAbstractItemView,
     QCheckBox,
@@ -52,15 +54,32 @@ from PyQt5.QtWidgets import (
     QTableWidget,
     QVBoxLayout,
     QWidget,
+    QDateTimeEdit,
+    QTimeEdit,
+    QAbstractSpinBox,
+    QRadioButton,
+    QStackedWidget,
+    QFrame,
 )
+from PySide6.QtGui import QFont, QTextCursor
 
 from . import config as cfg
-from . import duration_widget
 from . import version
+from . import utilities as util
 
 
 def MessageDialog(title: str, text: str, buttons: tuple) -> str:
+    """
+    show a generic message dialog and returns the text of the clicked button
 
+    Args:
+        title (str): Title of the dialog box
+        text (str): text of the dialog box
+        buttons (tuple): text for buttons
+
+    Return
+        str: text of the clicked button
+    """
     message = QMessageBox()
     message.setWindowTitle(title)
     message.setText(text)
@@ -68,116 +87,64 @@ def MessageDialog(title: str, text: str, buttons: tuple) -> str:
     for button in buttons:
         message.addButton(button, QMessageBox.YesRole)
 
-    # message.setWindowFlags(Qt.WindowStaysOnTopHint)
-    message.exec_()
+    message.setWindowFlags(message.windowFlags() | Qt.WindowStaysOnTopHint)
+    message.exec()
     return message.clickedButton().text()
 
 
-'''
-def error_message_box(task, error_type, error_file_name, error_lineno):
-    # do NOT use this function directly, use error_message function
-    """
-    show a critical dialog
-
-    """
-    QMessageBox.critical(None, cfg.programName, (f"BORIS version: {version.__version__}<br>"
-                                                 f"An error occured during the execution of <b>{task}</b>.<br>"
-                                                 f"Error: {error_type}<br>"
-                                                 f"in {error_file_name} "
-                                                 f"at line # {error_lineno}<br><br>"
-                                                 "to improve the software please report this problem at:<br>"
-                                                 '<a href="https://github.com/olivierfriard/BORIS/issues">'
-                                                 'https://github.com/olivierfriard/BORIS/issues</a><br>'
-                                                 "or by email (See the About page on the BORIS web site.<br><br>"
-                                                 "Thank you for your collaboration!"))
-'''
-
-
-def error_message_box(error_traceback):
-    # do NOT use this function directly, use error_message function
-    """
-    show a critical dialog
-
-    """
-    QMessageBox.critical(
-        None,
-        cfg.programName,
-        (
-            f"BORIS version: {version.__version__}<br><br>"
-            f"<b>An error has occured</b>:<br>"
-            f"{error_traceback}<br><br>"
-            "to improve the software please report this problem at:<br>"
-            '<a href="https://github.com/olivierfriard/BORIS/issues">'
-            "https://github.com/olivierfriard/BORIS/issues</a><br>"
-            "or by email (See the About page on the BORIS web site.<br><br>"
-            "Thank you for your collaboration!"
-        ),
-    )
-
-
-def error_message() -> None:
-    """
-    Show details about the error in a message box
-    write entry to log as CRITICAL
-    """
-
-    error_traceback = traceback.format_exc().replace("Traceback (most recent call last):", "").replace("\n", " ")
-
-    logging.critical(error_traceback)
-    error_message_box(error_traceback)
-
-
 def global_error_message(exception_type, exception_value, traceback_object):
     """
-    global error management
-    save error using loggin.critical and append error message to ~/boris.log
+    Global error management
+    save error using loggin.critical and stdout
     """
 
-    error_text: str = (
-        f"BORIS version: {version.__version__}\n"
-        f"OS: {platform.uname().system} {platform.uname().release} {platform.uname().version}\n"
-        f"CPU: {platform.uname().machine} {platform.uname().processor}\n"
-        f"Python {platform.python_version()} ({'64-bit' if sys.maxsize > 2**32 else '32-bit'})\n"
-        f"Qt {QT_VERSION_STR} - PyQt {PYQT_VERSION_STR}\n"
-        f"{dt.datetime.now():%Y-%m-%d %H:%M}\n\n"
-    )
+    error_text = "\n\nSystem info\n===========\n\n"
+    error_text += util.get_systeminfo()
+    error_text += f"Error succeded at {dt.datetime.now():%Y-%m-%d %H:%M}\n\n"
     error_text += "".join(traceback.format_exception(exception_type, exception_value, traceback_object))
 
+    # write to stdout
     logging.critical(error_text)
 
-    # append to boris.log file
-    with open(pl.Path("~").expanduser() / "boris.log", "a") as f_out:
-        f_out.write(error_text + "\n")
-        f_out.write("-" * 80 + "\n")
+    # write to $HOME/boris_error.log
+    try:
+        with open(pl.Path.home() / "boris_error.log", "w") as f_error:
+            f_error.write(error_text)
+    except Exception:
+        logging.critical(f"Impossible to write to {pl.Path.home() / 'boris_error.log'}")
 
     # copy to clipboard
     cb = QApplication.clipboard()
-    cb.clear(mode=cb.Clipboard)
-    cb.setText(error_text, mode=cb.Clipboard)
-
-    error_text: str = error_text.replace("\r\n", "\n").replace("\n", "<br>")
+    cb.clear()
+    cb.setText(error_text)
 
     text: str = (
-        f"<b>An error has occured</b>:<br><br>"
-        f"{error_text}<br>"
-        "to improve the software please report this problem at:<br>"
-        '<a href="https://github.com/olivierfriard/BORIS/issues">'
-        "https://github.com/olivierfriard/BORIS/issues</a><br>"
-        "Please no screenshot, the error message was copied to the clipboard.<br><br>"
-        "Thank you for your collaboration!"
+        f"An error has occured!\n\n"
+        "to improve the software please report this problem at:\n"
+        "https://github.com/olivierfriard/BORIS/issues\n\n"
+        "Please no screenshot, the error message was copied to the clipboard.\n\n"
+        "Thank you for your collaboration!\n\n"
+        f"{error_text}"
     )
 
-    errorbox = QMessageBox()
-    errorbox.setWindowTitle("BORIS error occured")
-    errorbox.setText(text)
-    errorbox.setTextFormat(Qt.RichText)
-    errorbox.setStandardButtons(QMessageBox.Abort)
+    errorbox = Results_dialog()
+
+    errorbox.setWindowTitle("BORIS - An error occured")
+    errorbox.pbOK.setText("Abort")
+    errorbox.pbCancel.setVisible(True)
+    errorbox.pbCancel.setText("Ignore and try to continue")
 
-    _ = errorbox.addButton("Ignore and try to continue", QMessageBox.RejectRole)
+    font = QFont()
+    font.setFamily("monospace")
+    errorbox.ptText.setFont(font)
+    errorbox.ptText.clear()
+    errorbox.ptText.appendPlainText(text)
+
+    errorbox.ptText.moveCursor(QTextCursor.Start)
 
     ret = errorbox.exec_()
 
-    if ret == QMessageBox.Abort:
+    if ret == 1:  # Abort
         sys.exit(1)
 
 
@@ -194,6 +161,319 @@ class Info_widget(QWidget):
         self.setLayout(layout)
 
 
+class get_time_widget(QWidget):
+    """
+    widget for selecting a time in various formats: seconds, HH:MM:SS:ZZZ or YYYY-mm-DD HH:MM:SS:ZZZ
+    """
+
+    def __init__(self, time_value=dec(0), parent=None):
+        super().__init__(parent)
+
+        self.setWindowTitle("BORIS")
+
+        self.widget = QWidget()
+        self.widget.setObjectName("widget")
+        self.widget.setGeometry(QRect(130, 220, 302, 63))
+        self.verticalLayout_3 = QVBoxLayout(self.widget)
+        self.verticalLayout_3.setObjectName("verticalLayout_3")
+        self.verticalLayout_3.setContentsMargins(0, 0, 0, 0)
+        self.horizontalLayout_3 = QHBoxLayout()
+        self.horizontalLayout_3.setObjectName("horizontalLayout_3")
+        self.verticalLayout_2 = QVBoxLayout()
+        self.verticalLayout_2.setObjectName("verticalLayout_2")
+        self.label = QLabel(self.widget)
+        self.label.setObjectName("label")
+
+        self.verticalLayout_2.addWidget(self.label)
+
+        self.pb_sign = QPushButton(self.widget)
+        self.pb_sign.setObjectName("pb_sign")
+        self.pb_sign.setMaximumSize(QSize(40, 16777215))
+
+        self.verticalLayout_2.addWidget(self.pb_sign)
+
+        self.horizontalLayout_3.addLayout(self.verticalLayout_2)
+
+        self.verticalLayout = QVBoxLayout()
+        self.verticalLayout.setObjectName("verticalLayout")
+        self.horizontalLayout = QHBoxLayout()
+        self.horizontalLayout.setObjectName("horizontalLayout")
+        self.rb_seconds = QRadioButton(self.widget)
+        self.rb_seconds.setObjectName("rb_seconds")
+
+        self.horizontalLayout.addWidget(self.rb_seconds)
+
+        self.rb_time = QRadioButton(self.widget)
+        self.rb_time.setObjectName("rb_time")
+
+        self.horizontalLayout.addWidget(self.rb_time)
+
+        self.rb_datetime = QRadioButton(self.widget)
+        self.rb_datetime.setObjectName("rb_datetime")
+
+        self.horizontalLayout.addWidget(self.rb_datetime)
+
+        self.horizontalLayout.addStretch()
+
+        self.verticalLayout.addLayout(self.horizontalLayout)
+
+        self.stackedWidget = QStackedWidget(self.widget)
+        self.stackedWidget.setObjectName("stackedWidget")
+        self.stackedWidget.setFrameShape(QFrame.NoFrame)
+        self.seconds = QWidget()
+        self.seconds.setObjectName("seconds")
+        self.widget1 = QWidget(self.seconds)
+        self.widget1.setObjectName("widget1")
+        # self.widget1.setGeometry(QRect(10, 0, 163, 27))
+        self.horizontalLayout_4 = QHBoxLayout(self.widget1)
+        self.horizontalLayout_4.setObjectName("horizontalLayout_4")
+        self.horizontalLayout_4.setContentsMargins(0, 0, 0, 0)
+        self.le_seconds = QLineEdit(self.widget1)
+        self.le_seconds.setObjectName("le_seconds")
+
+        self.horizontalLayout_4.addWidget(self.le_seconds)
+
+        self.lb_seconds = QLabel(self.widget1)
+        self.lb_seconds.setObjectName("lb_seconds")
+
+        self.horizontalLayout_4.addWidget(self.lb_seconds)
+
+        self.horizontalLayout_4.addStretch()
+
+        self.stackedWidget.addWidget(self.seconds)
+        self.hhmmss = QWidget()
+        self.hhmmss.setObjectName("hhmmss")
+        self.widget2 = QWidget(self.hhmmss)
+        self.widget2.setMinimumWidth(500)
+        self.widget2.setObjectName("widget2")
+        self.widget2.setGeometry(QRect(0, 0, 213, 28))
+        self.horizontalLayout_2 = QHBoxLayout(self.widget2)
+        self.horizontalLayout_2.setObjectName("horizontalLayout_2")
+        self.horizontalLayout_2.setContentsMargins(0, 0, 0, 0)
+        self.lb_hour = QLabel(self.widget2)
+        self.lb_hour.setObjectName("lb_hour")
+
+        self.horizontalLayout_2.addWidget(self.lb_hour)
+
+        self.sb_hour = QSpinBox(self.widget2)
+        self.sb_hour.setObjectName("sb_hour")
+        self.sb_hour.setButtonSymbols(QAbstractSpinBox.NoButtons)
+
+        self.horizontalLayout_2.addWidget(self.sb_hour)
+
+        self.lb_hhmmss = QLabel(self.widget2)
+        self.lb_hhmmss.setObjectName("lb_hhmmss")
+
+        self.horizontalLayout_2.addWidget(self.lb_hhmmss)
+
+        self.te_time = QTimeEdit(self.widget2)
+        self.te_time.setObjectName("te_time")
+        self.te_time.adjustSize()
+        # self.te_time.setMinimumWidth(200)
+        # self.widget2.adjustSize()
+
+        self.horizontalLayout_2.addWidget(self.te_time)
+
+        self.horizontalLayout_2.addStretch()
+
+        self.stackedWidget.addWidget(self.hhmmss)
+        self.page_2 = QWidget()
+        self.page_2.setObjectName("page_2")
+        self.dte = QDateTimeEdit(self.page_2)
+
+        self.dte.setObjectName("dte")
+        # self.dte.setGeometry(QRect(10, 0, 164, 26))
+        self.stackedWidget.addWidget(self.page_2)
+
+        self.verticalLayout.addWidget(self.stackedWidget)
+
+        self.horizontalLayout_3.addLayout(self.verticalLayout)
+
+        self.verticalLayout_3.addLayout(self.horizontalLayout_3)
+
+        self.line = QFrame(self.widget)
+        self.line.setObjectName("line")
+        self.line.setFrameShape(QFrame.HLine)
+        self.line.setFrameShadow(QFrame.Sunken)
+
+        self.verticalLayout_3.addWidget(self.line)
+
+        self.setLayout(self.verticalLayout_3)
+
+        self.stackedWidget.setCurrentIndex(0)
+
+        self.label.setText("")
+        self.pb_sign.setText("+")
+        self.rb_seconds.setText("Seconds")
+        self.rb_time.setText("hh:mm:ss")
+        self.rb_datetime.setText("Date time")
+        self.le_seconds.setText("")
+        self.lb_seconds.setText("seconds")
+        self.lb_hour.setText("hour")
+        self.lb_hhmmss.setText("mm:ss.ms")
+        self.te_time.setDisplayFormat("mm:ss.zzz")
+        self.dte.setDisplayFormat("yyyy-MM-dd hh:mm:ss:zzz")
+        self.dte.adjustSize()
+        font = QFont()
+        font.setPointSize(14)
+        self.pb_sign.setFont(font)
+
+        self.rb_seconds.toggled.connect(self.format_changed)
+        self.rb_time.toggled.connect(self.format_changed)
+        self.rb_datetime.toggled.connect(self.format_changed)
+        self.sb_hour.setMaximum(cfg.HOUR_CUTOFF)
+        self.pb_sign.clicked.connect(self.pb_sign_clicked)
+
+        if time_value:
+            self.set_time(time_value)
+
+        self.format_changed()
+
+        self.adjustSize()
+
+    def format_changed(self):
+        if self.rb_seconds.isChecked():
+            self.stackedWidget.setCurrentIndex(0)
+        if self.rb_time.isChecked():
+            self.stackedWidget.setCurrentIndex(1)
+        if self.rb_datetime.isChecked():
+            self.stackedWidget.setCurrentIndex(2)
+
+        self.le_seconds.setEnabled(self.rb_seconds.isChecked())
+        self.le_seconds.adjustSize()
+        self.lb_seconds.setEnabled(self.rb_seconds.isChecked())
+        self.sb_hour.setEnabled(self.rb_time.isChecked())
+        self.te_time.setEnabled(self.rb_time.isChecked())
+        self.lb_hour.setEnabled(self.rb_time.isChecked())
+        self.lb_hhmmss.setEnabled(self.rb_time.isChecked())
+        self.dte.setEnabled(self.rb_datetime.isChecked())
+
+    def pb_sign_clicked(self):
+        if self.pb_sign.text() == "+":
+            self.pb_sign.setText("-")
+        else:
+            self.pb_sign.setText("+")
+
+    def get_time(self) -> Union[dec, None]:
+        """
+        Get time from the selected format in the time widget
+
+        Returns:
+            dec: time in seconds (None if no format selected)
+        """
+
+        time_sec = dec("NaN")
+
+        if self.rb_seconds.isChecked():
+            try:
+                time_sec = float(self.le_seconds.text())
+            except Exception:
+                QMessageBox.warning(
+                    None,
+                    cfg.programName,
+                    f"The value of seconds ({self.le_seconds.text()}) is not a decimal number",
+                    QMessageBox.Ok | QMessageBox.Default,
+                    QMessageBox.NoButton,
+                )
+                return dec("NaN")
+
+        if self.rb_time.isChecked():
+            time_sec = self.sb_hour.value() * 3600
+            time_sec += self.te_time.time().msecsSinceStartOfDay() / 1000
+
+        if self.rb_datetime.isChecked():
+            time_sec = self.dte.dateTime().toMSecsSinceEpoch() / 1000
+
+        if self.pb_sign.text() == "-":
+            time_sec = -time_sec
+
+        return dec(time_sec).quantize(dec("0.001"))  # if time_sec is not None else None
+
+    def set_time(self, new_time: dec) -> None:
+        """
+        set time on time widget
+        """
+
+        if math.isnan(new_time):
+            return
+
+        self.pb_sign.setText("-" if new_time < 0 else "+")
+
+        # seconds
+        self.le_seconds.setText(f"{new_time:0.3f}")
+
+        if new_time <= cfg.DATE_CUTOFF:  # hh:mm:ss.zzz
+            h = int(abs(new_time) // 3600)
+            m = int((abs(new_time) - h * 3600) // 60)
+            s = int((abs(new_time) - h * 3600 - m * 60))
+            ms = round((abs(new_time) - h * 3600 - m * 60 - s) * 1000)
+
+            self.sb_hour.setValue(h)
+            self.te_time.setTime(QTime(0, m, s, ms))
+        else:
+            self.sb_hour.setValue(0)
+            self.te_time.setTime(QTime(0, 0, 0, 0))
+
+            self.dte.setDateTime(QDateTime().fromMSecsSinceEpoch(int(new_time * 1000)))
+            self.rb_datetime.setChecked(True)
+
+
+class Ask_time(QDialog):
+    """
+    Qdialog class for asking time to user
+    User can select a time format between seconds, HHMMSS.zzz or YYY-mm-DD HH:MM:SS.zzz
+    """
+
+    def __init__(self, time_value=0):
+        super().__init__()
+        self.setWindowTitle("")
+
+        hbox = QVBoxLayout(self)
+        self.label = QLabel()
+        self.label.setText("")
+        hbox.addWidget(self.label)
+
+        self.time_widget = get_time_widget(time_value)
+
+        hbox.addWidget(self.time_widget)
+
+        self.pbOK = QPushButton(cfg.OK, clicked=self.pb_ok_clicked)
+        self.pbOK.setDefault(True)
+
+        self.pbCancel = QPushButton(cfg.CANCEL)
+        self.pbCancel.clicked.connect(self.reject)
+
+        self.hbox2 = QHBoxLayout(self)
+        self.hbox2.addItem(QSpacerItem(241, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
+        self.hbox2.addWidget(self.pbCancel)
+        self.hbox2.addWidget(self.pbOK)
+        hbox.addLayout(self.hbox2)
+        self.setLayout(hbox)
+
+        # if time_value:
+        #    self.time_widget.set_time(time_value)
+
+    def pb_ok_clicked(self):
+        if (
+            not self.time_widget.rb_seconds.isChecked()
+            and not self.time_widget.rb_time.isChecked()
+            and not self.time_widget.rb_datetime.isChecked()
+        ):
+            QMessageBox.warning(
+                None,
+                cfg.programName,
+                "Select an option",
+                QMessageBox.Ok | QMessageBox.Default,
+                QMessageBox.NoButton,
+            )
+            return
+        # test time value
+        if self.time_widget.get_time().is_nan():
+            return
+
+        self.accept()
+
+
 class Video_overlay_dialog(QDialog):
     """
     dialog to ask image file and position for video overlay
@@ -203,28 +483,37 @@ class Video_overlay_dialog(QDialog):
         super().__init__()
 
         vlayout = QVBoxLayout()
-        vlayout.addWidget(QLabel("File"))
+        self.cb_player = QComboBox()
+        vlayout.addWidget(self.cb_player)
+
         hbox = QHBoxLayout()
+        hbox.addWidget(QLabel("Image file"))
         self.le_file_path = QLineEdit()
         hbox.addWidget(self.le_file_path)
+        vlayout.addLayout(hbox)
+
+        hbox = QHBoxLayout()
         self.pb_browse = QPushButton("Browse", self, clicked=self.browse)
+        hbox.addItem(QSpacerItem(241, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
         hbox.addWidget(self.pb_browse)
         vlayout.addLayout(hbox)
 
-        vlayout.addWidget(QLabel("Position: x,y"))
+        hbox = QHBoxLayout()
+        hbox.addWidget(QLabel("Position: x,y"))
         self.le_overlay_position = QLineEdit()
-        vlayout.addWidget(self.le_overlay_position)
+        hbox.addWidget(self.le_overlay_position)
+        vlayout.addLayout(hbox)
 
-        vlayout.addWidget(QLabel("Transparency %"))
+        hbox = QHBoxLayout()
+        hbox.addWidget(QLabel("Transparency %"))
         self.sb_overlay_transparency = QSpinBox()
         self.sb_overlay_transparency.setRange(0, 100)
         self.sb_overlay_transparency.setSingleStep(1)
-        self.sb_overlay_transparency.setValue(0)
-        vlayout.addWidget(self.sb_overlay_transparency)
-        self.sb_overlay_transparency.setEnabled(False)
+        self.sb_overlay_transparency.setValue(90)
+        hbox.addWidget(self.sb_overlay_transparency)
+        vlayout.addLayout(hbox)
 
-        self.cb_player = QComboBox()
-        vlayout.addWidget(self.cb_player)
+        # self.sb_overlay_transparency.setEnabled(False)
 
         hbox = QHBoxLayout()
         self.pb_cancel = QPushButton("Cancel", self, clicked=self.reject)
@@ -239,8 +528,7 @@ class Video_overlay_dialog(QDialog):
         self.setLayout(vlayout)
 
     def browse(self):
-        fn = QFileDialog().getOpenFileName(self, "Choose an image file", "", "PNG files (*.png);;All files (*)")
-        file_name = fn[0] if type(fn) is tuple else fn
+        file_name, _ = QFileDialog.getOpenFileName(self, "Choose an image file", "", "PNG files (*.png);;All files (*)")
         if file_name:
             self.le_file_path.setText(file_name)
 
@@ -284,7 +572,8 @@ class Input_dialog(QDialog):
     dialog for user input. Elements can be:
         checkbox (cb): Tuple(str, str, bool)
         lineedit (le): Tuple(str, str)
-        spinbox (sp)
+        spinbox (sb)
+        doubleSpinbox (dsb)
         items list (il)
 
     """
@@ -301,7 +590,6 @@ class Input_dialog(QDialog):
 
         self.elements: dict = {}
         for element in elements_list:
-
             if element[0] == "cb":  # checkbox
                 self.elements[element[1]] = QCheckBox(element[1])
                 self.elements[element[1]].setChecked(element[2])
@@ -334,7 +622,7 @@ class Input_dialog(QDialog):
                 # 3 - maximum value
                 # 4 - step
                 # 5 - initial value
-                # 6 - number of decimas
+                # 6 - number of decimals
 
                 lb = QLabel(element[1])
                 hbox.addWidget(lb)
@@ -353,15 +641,15 @@ class Input_dialog(QDialog):
                 self.elements[element[1]] = QComboBox()
                 self.elements[element[1]].addItems([x[0] for x in element[2]])  # take first element of tuple
                 try:
-                    self.elements[element[1]].setCurrentIndex(
-                        [idx for idx, x in enumerate(element[2]) if x[1] == "selected"][0]
-                    )
-                except:
+                    self.elements[element[1]].setCurrentIndex([idx for idx, x in enumerate(element[2]) if x[1] == "selected"][0])
+                except Exception:
                     self.elements[element[1]].setCurrentIndex(0)
                 hbox.addWidget(self.elements[element[1]])
 
         hbox2 = QHBoxLayout()
 
+        hbox2.addItem(QSpacerItem(40, 20, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum))
+
         self.pbCancel = QPushButton(cfg.CANCEL)
         self.pbCancel.clicked.connect(self.reject)
         hbox2.addWidget(self.pbCancel)
@@ -375,14 +663,13 @@ class Input_dialog(QDialog):
         self.setLayout(hbox)
 
 
-class DuplicateBehaviorCode(QDialog):
+class Duplicate_items(QDialog):
     """
-    let user show between behaviors that are coded by same key
+    let user show between behaviors/subjects that are coded by same key
     """
 
     def __init__(self, text, codes_list):
-
-        super(DuplicateBehaviorCode, self).__init__()
+        super(Duplicate_items, self).__init__()
 
         self.setWindowTitle(cfg.programName)
         self.setWindowFlags(Qt.WindowStaysOnTopHint)
@@ -406,13 +693,17 @@ class DuplicateBehaviorCode(QDialog):
 
         Vlayout.addWidget(self.lw)
 
-        pbCancel = QPushButton("Cancel")
-        pbCancel.clicked.connect(self.reject)
-        Vlayout.addWidget(pbCancel)
-        pbOK = QPushButton("OK")
+        hlayout = QHBoxLayout()
+        hlayout.addItem(QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
+
+        pbCancel = QPushButton("Cancel", clicked=self.reject)
+        hlayout.addWidget(pbCancel)
+
+        pbOK = QPushButton("OK", clicked=self.accept)
         pbOK.setDefault(True)
-        pbOK.clicked.connect(self.pbOK_clicked)
-        Vlayout.addWidget(pbOK)
+        hlayout.addWidget(pbOK)
+
+        Vlayout.addLayout(hlayout)
 
         self.setLayout(Vlayout)
 
@@ -426,9 +717,8 @@ class DuplicateBehaviorCode(QDialog):
         """
         if self.lw.selectedItems():
             return self.lw.selectedItems()[0].text()
-
-    def pbOK_clicked(self):
-        self.accept()
+        else:
+            return None
 
 
 class ChooseObservationsToImport(QDialog):
@@ -437,7 +727,6 @@ class ChooseObservationsToImport(QDialog):
     """
 
     def __init__(self, text, observations_list):
-
         super(ChooseObservationsToImport, self).__init__()
 
         self.setWindowTitle(cfg.programName)
@@ -485,50 +774,13 @@ class ChooseObservationsToImport(QDialog):
         return [item.text() for item in self.lw.selectedItems()]
 
 
-class Ask_time(QDialog):
-    """
-    "Ask time" dialog box using duration widget in duration_widget module
-    """
-
-    def __init__(self, time_format):
-        super().__init__()
-        hbox = QVBoxLayout(self)
-        self.label = QLabel()
-        self.label.setText("Go to time")
-        hbox.addWidget(self.label)
-
-        self.time_widget = duration_widget.Duration_widget()
-        if time_format == cfg.HHMMSS:
-            self.time_widget.set_format_hhmmss()
-        if time_format == cfg.S:
-            self.time_widget.set_format_s()
-
-        hbox.addWidget(self.time_widget)
-
-        self.pbOK = QPushButton("OK")
-        self.pbOK.clicked.connect(self.accept)
-        self.pbOK.setDefault(True)
-
-        self.pbCancel = QPushButton("Cancel")
-        self.pbCancel.clicked.connect(self.reject)
-
-        self.hbox2 = QHBoxLayout(self)
-        self.hbox2.addItem(QSpacerItem(241, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
-        self.hbox2.addWidget(self.pbCancel)
-        self.hbox2.addWidget(self.pbOK)
-        hbox.addLayout(self.hbox2)
-        self.setLayout(hbox)
-        self.setWindowTitle("Time")
-
-
 class FindInEvents(QWidget):
     """
     "find in events" dialog box
     """
 
-    clickSignal = pyqtSignal(str)
-
-    currentIdx = -1
+    clickSignal = Signal(str)
+    currentIdx: int = -1
 
     def __init__(self):
         super().__init__()
@@ -571,9 +823,10 @@ class FindInEvents(QWidget):
         hbox.addWidget(self.lb_message)
 
         hbox2 = QHBoxLayout()
+        hbox2.addItem(QSpacerItem(40, 20, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum))
         self.pbOK = QPushButton("Find")
         self.pbOK.clicked.connect(lambda: self.click("FIND"))
-        self.pbCancel = QPushButton("Close")
+        self.pbCancel = QPushButton(cfg.CLOSE)
         self.pbCancel.clicked.connect(lambda: self.click("CLOSE"))
         hbox2.addWidget(self.pbCancel)
         hbox2.addWidget(self.pbOK)
@@ -590,10 +843,7 @@ class FindReplaceEvents(QWidget):
     "find replace events" dialog box
     """
 
-    clickSignal = pyqtSignal(str)
-    """
-    sendEventSignal = pyqtSignal(QEvent)
-    """
+    clickSignal = Signal(str)
 
     def __init__(self):
         super().__init__()
@@ -602,21 +852,9 @@ class FindReplaceEvents(QWidget):
 
         hbox = QVBoxLayout()
 
-        self.cbSubject = QCheckBox("Subject")
-        self.cbSubject.setChecked(False)
-        hbox.addWidget(self.cbSubject)
-
-        self.cbBehavior = QCheckBox("Behavior")
-        self.cbBehavior.setChecked(False)
-        hbox.addWidget(self.cbBehavior)
-
-        self.cbModifier = QCheckBox("Modifiers")
-        self.cbModifier.setChecked(False)
-        hbox.addWidget(self.cbModifier)
-
-        self.cbComment = QCheckBox("Comment")
-        self.cbComment.setChecked(False)
-        hbox.addWidget(self.cbComment)
+        self.combo_fields = QComboBox()
+        self.combo_fields.addItems(("Choose a field", "Subject", "Behavior", "Modifiers", "Comment"))
+        hbox.addWidget(self.combo_fields)
 
         self.lbFind = QLabel("Find")
         hbox.addWidget(self.lbFind)
@@ -630,7 +868,7 @@ class FindReplaceEvents(QWidget):
         self.replaceText = QLineEdit()
         hbox.addWidget(self.replaceText)
 
-        self.cbFindInSelectedEvents = QCheckBox("Find/Replace in selected events")
+        self.cbFindInSelectedEvents = QCheckBox("Find/Replace only in selected events")
         self.cbFindInSelectedEvents.setChecked(False)
         hbox.addWidget(self.cbFindInSelectedEvents)
 
@@ -640,6 +878,8 @@ class FindReplaceEvents(QWidget):
 
         hbox2 = QHBoxLayout()
 
+        hbox2.addItem(QSpacerItem(40, 20, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum))
+
         self.pbCancel = QPushButton(cfg.CANCEL, clicked=lambda: self.click("CANCEL"))
         hbox2.addWidget(self.pbCancel)
 
@@ -650,68 +890,76 @@ class FindReplaceEvents(QWidget):
         hbox2.addWidget(self.pbFindReplaceAll)
 
         hbox.addLayout(hbox2)
+
+        self.lb_results = QLabel(" ")
+        hbox.addWidget(self.lb_results)
+
         self.setLayout(hbox)
 
     def click(self, msg):
         self.clickSignal.emit(msg)
 
 
-'''
-class explore_project_dialog(QDialog):
+class Results_dialog(QDialog):
     """
-    "explore project" dialog box
+    widget for visualizing text output in HTML
     """
 
     def __init__(self):
         super().__init__()
 
-        self.setWindowTitle("Explore project")
-
-        hbox = QVBoxLayout()
-
-        hbox.addWidget(QLabel("Search in all observations"))
+        self.dataset = False
 
-        self.lb_subject = QLabel("Subject")
-        hbox.addWidget(self.lb_subject)
-        self.find_subject = QLineEdit()
-        hbox.addWidget(self.find_subject)
+        self.setWindowTitle("")
 
-        self.lb_behav = QLabel("Behaviors")
-        hbox.addWidget(self.lb_behav)
-        self.find_behavior = QLineEdit()
-        hbox.addWidget(self.find_behavior)
+        hbox = QVBoxLayout()
 
-        self.lb_modifier = QLabel("Modifier")
-        hbox.addWidget(self.lb_modifier)
-        self.find_modifier = QLineEdit()
-        hbox.addWidget(self.find_modifier)
+        self.lb = QLabel("")
+        hbox.addWidget(self.lb)
 
-        self.lb_comment = QLabel("Comment")
-        hbox.addWidget(self.lb_comment)
-        self.find_comment = QLineEdit()
-        hbox.addWidget(self.find_comment)
+        self.ptText = QPlainTextEdit()
+        self.ptText.setReadOnly(True)
+        hbox.addWidget(self.ptText)
 
-        self.cb_case_sensitive = QCheckBox("Case sensitive")
-        self.cb_case_sensitive.setChecked(False)
-        hbox.addWidget(self.cb_case_sensitive)
+        hbox2 = QHBoxLayout()
+        hbox2.addItem(QSpacerItem(241, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
 
-        self.lb_message = QLabel()
-        hbox.addWidget(self.lb_message)
+        self.pbSave = QPushButton("Save results", clicked=self.save_results)
+        hbox2.addWidget(self.pbSave)
 
-        hbox2 = QHBoxLayout()
-        self.pbOK = QPushButton("Find")
-        self.pbOK.clicked.connect(self.accept)
-        self.pbCancel = QPushButton("Cancel")
-        self.pbCancel.clicked.connect(self.reject)
+        self.pbCancel = QPushButton(cfg.CANCEL, clicked=self.reject)
         hbox2.addWidget(self.pbCancel)
+        self.pbCancel.setVisible(False)
+
+        self.pbOK = QPushButton(cfg.OK, clicked=self.accept)
         hbox2.addWidget(self.pbOK)
-        hbox.addLayout(hbox2)
 
+        hbox.addLayout(hbox2)
         self.setLayout(hbox)
-'''
 
+        self.resize(800, 640)
 
-class Results_dialog(QDialog):
+    def save_results(self):
+        """
+        save content of self.ptText
+        """
+
+        if not self.dataset:
+            file_name, _ = QFileDialog().getSaveFileName(self, "Save results", "", "Text files (*.txt *.tsv);;All files (*)")
+
+            if not file_name:
+                return
+            try:
+                with open(file_name, "w") as f:
+                    f.write(self.ptText.toPlainText())
+            except Exception:
+                QMessageBox.critical(self, cfg.programName, f"The file {file_name} can not be saved")
+
+        else:
+            self.done(cfg.SAVE_DATASET)
+
+
+class Results_dialog_exit_code(QDialog):
     """
     widget for visualizing text output
     """
@@ -733,32 +981,35 @@ class Results_dialog(QDialog):
         hbox.addWidget(self.ptText)
 
         hbox2 = QHBoxLayout()
+        hbox2.addItem(QSpacerItem(241, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
+
         self.pbSave = QPushButton("Save results", clicked=self.save_results)
         hbox2.addWidget(self.pbSave)
 
-        hbox2.addItem(QSpacerItem(241, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
+        self.pb1 = QPushButton("1", clicked=lambda: self.done_(1))
+        hbox2.addWidget(self.pb1)
 
-        self.pbCancel = QPushButton(cfg.CANCEL, clicked=self.reject)
-        hbox2.addWidget(self.pbCancel)
-        self.pbCancel.setVisible(False)
+        self.pb2 = QPushButton("2", clicked=lambda: self.done_(2))
+        hbox2.addWidget(self.pb2)
 
-        self.pbOK = QPushButton(cfg.OK)
-        self.pbOK.clicked.connect(self.accept)
-        hbox2.addWidget(self.pbOK)
+        self.pb3 = QPushButton("3", clicked=lambda: self.done_(3))
+        hbox2.addWidget(self.pb3)
 
         hbox.addLayout(hbox2)
         self.setLayout(hbox)
 
         self.resize(800, 640)
 
+    def done_(self, status):
+        self.done(status)
+
     def save_results(self):
         """
         save content of self.ptText
         """
 
         if not self.dataset:
-            fn = QFileDialog().getSaveFileName(self, "Save results", "", "Text files (*.txt *.tsv);;All files (*)")
-            file_name = fn[0] if type(fn) is tuple else fn
+            file_name, _ = QFileDialog().getSaveFileName(self, "Save results", "", "Text files (*.txt *.tsv);;All files (*)")
 
             if not file_name:
                 return
@@ -772,9 +1023,9 @@ class Results_dialog(QDialog):
             self.done(cfg.SAVE_DATASET)
 
 
-class View_data_head(QDialog):
+class View_data(QDialog):
     """
-    widget for visualizing first rows of data file
+    widget for visualizing rows of data file
     """
 
     def __init__(self):
@@ -788,8 +1039,18 @@ class View_data_head(QDialog):
         vbox.addWidget(self.lb)
 
         self.tw = QTableWidget()
+        self.tw.verticalHeader().hide()
         vbox.addWidget(self.tw)
 
+        vbox.addWidget(QLabel("Descriptive statistics"))
+
+        self.stats = QPlainTextEdit()
+        font = QFont()
+        font.setFamily("Monospace")
+        self.stats.setFont(font)
+
+        vbox.addWidget(self.stats)
+
         self.label = QLabel("Enter the column indices to plot (time, value) separated by comma (,)")
         vbox.addWidget(self.label)
 
@@ -798,17 +1059,19 @@ class View_data_head(QDialog):
 
         hbox2 = QHBoxLayout()
 
-        self.pbCancel = QPushButton("Cancel", clicked=self.reject)
+        hbox2.addItem(QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
+
+        self.pbCancel = QPushButton(cfg.CANCEL, clicked=self.reject)
         hbox2.addWidget(self.pbCancel)
 
-        self.pbOK = QPushButton("OK", clicked=self.accept)
+        self.pbOK = QPushButton(cfg.OK, clicked=self.accept)
         hbox2.addWidget(self.pbOK)
 
         vbox.addLayout(hbox2)
 
         self.setLayout(vbox)
 
-        self.resize(540, 640)
+        self.resize(800, 640)
 
 
 class View_explore_project_results(QWidget):
@@ -816,7 +1079,7 @@ class View_explore_project_results(QWidget):
     widget for visualizing results of explore project
     """
 
-    double_click_signal = pyqtSignal(str, int)
+    double_click_signal = Signal(str, int)
 
     def __init__(self):
         super().__init__()
@@ -834,14 +1097,12 @@ class View_explore_project_results(QWidget):
         vbox.addWidget(self.tw)
 
         hbox2 = QHBoxLayout()
-        hbox2.addWidget(QPushButton("OK", clicked=self.close))
+        hbox2.addItem(QSpacerItem(40, 20, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum))
+        hbox2.addWidget(QPushButton(cfg.CLOSE, clicked=self.close))
 
         vbox.addLayout(hbox2)
 
         self.setLayout(vbox)
 
-        # self.resize(540, 640)
-
     def tw_cellDoubleClicked(self, r, c):
-
         self.double_click_signal.emit(self.tw.item(r, 0).text(), int(self.tw.item(r, 1).text()))