boris-behav-obs 9.7.7__py3-none-any.whl

boris/duration_widget.py

@@ -0,0 +1,238 @@
+"""
+
+widget to edit duration > 24 h or < 0
+
+https://stackoverflow.com/questions/44380202/creating-a-custom-widget-in-PySide6
+"""
+
+from decimal import Decimal as dec
+
+from PySide6.QtWidgets import (
+    QWidget,
+    QHBoxLayout,
+    QPushButton,
+    QSpinBox,
+    QLabel,
+    QSpacerItem,
+    QSizePolicy,
+    QDoubleSpinBox,
+    QStackedWidget,
+    QRadioButton,
+)
+
+from PySide6.QtCore import Signal
+
+from . import config as cfg
+
+
+class Widget_hhmmss(QWidget):
+    time_changed_signal = Signal(float)
+
+    def __init__(self, parent=None):
+        QWidget.__init__(self, parent=parent)
+
+        lay = QHBoxLayout(self)
+        lay.setSpacing(0)
+        lay.setContentsMargins(0, 0, 0, 0)
+
+        self.sign = QPushButton("+")
+        self.sign.clicked.connect(self.change_sign)
+        self.sign.setStyleSheet("font-size:12px;")
+        lay.addWidget(self.sign)
+
+        self.hours = QSpinBox()
+        self.hours.setValue(0)
+        self.hours.setMinimum(0)
+        self.hours.setMaximum(2**31 - 1)
+        self.hours.valueChanged.connect(self.update_time_value)
+        lay.addWidget(self.hours)
+        lay.addWidget(QLabel(":"))
+
+        self.minutes = QSpinBox()
+        self.minutes.setMinimum(-1)
+        self.minutes.setMaximum(60)
+        self.minutes.setPrefix("0")
+        self.minutes.valueChanged.connect(lambda value, x=self.minutes: self.value_changed(value, x, 0, 59))
+        lay.addWidget(self.minutes)
+        lay.addWidget(QLabel(":"))
+
+        self.seconds = QSpinBox()
+        self.seconds.setMinimum(-1)
+        self.seconds.setMaximum(60)
+        self.seconds.setPrefix("0")
+        self.seconds.valueChanged.connect(lambda value, x=self.seconds: self.value_changed(value, x, 0, 59))
+        lay.addWidget(self.seconds)
+        lay.addWidget(QLabel(":"))
+
+        self.milliseconds = QSpinBox()
+        self.milliseconds.setMinimum(-1)
+        self.milliseconds.setMaximum(1000)
+        self.milliseconds.setPrefix("00")
+        self.milliseconds.valueChanged.connect(lambda value, x=self.milliseconds: self.value_changed(value, x, 0, 999))
+        lay.addWidget(self.milliseconds)
+
+        spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
+        lay.addItem(spacerItem)
+        self.setLayout(lay)
+
+    def change_sign(self):
+        """
+        sign has changed
+        """
+        self.sign.setText("+" if self.sign.text() == "-" else "-")
+        self.update_time_value()
+
+    def update_time_value(self):
+        new_time = self.hours.value() * 3600 + self.minutes.value() * 60 + self.seconds.value() + self.milliseconds.value() / 1000
+        if self.sign.text() == "-":
+            new_time = -new_time
+
+        self.time_changed_signal.emit(new_time)
+
+    def value_changed(self, new_value, widget, val_min, val_max):
+        """
+        time value changed
+        """
+
+        if new_value > val_max:
+            widget.setValue(val_min)
+            widget.setPrefix("0" if val_max < 100 else "00")
+            self.update_time_value()
+            return
+
+        if new_value < val_min:
+            widget.setValue(val_max)
+            widget.setPrefix("")
+            self.update_time_value()
+            return
+
+        if new_value < 10:
+            widget.setPrefix("0" if val_max < 100 else "00")
+        elif new_value < 100:
+            widget.setPrefix("" if val_max < 100 else "0")
+        else:
+            widget.setPrefix("")
+
+        self.update_time_value()
+
+
+class Widget_seconds(QWidget):
+    time_changed_signal = Signal(float)
+
+    def __init__(self, parent=None):
+        QWidget.__init__(self, parent=parent)
+        lay = QHBoxLayout(self)
+        lay.setSpacing(0)
+        lay.setContentsMargins(0, 0, 0, 0)
+
+        self.seconds2 = QDoubleSpinBox()
+        self.seconds2.setValue(0)
+        self.seconds2.setMinimum(-100_000_000)
+        self.seconds2.setMaximum(100_000_000)
+        self.seconds2.setDecimals(3)
+        self.seconds2.valueChanged.connect(self.value_changed)
+        lay.addWidget(self.seconds2)
+
+        spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
+        lay.addItem(spacerItem)
+
+        self.setLayout(lay)
+
+    def value_changed(self, v):
+        self.time_changed_signal.emit(v)
+
+
+class Duration_widget(QWidget):
+    def __init__(self, time_value=0, parent=None):
+        super().__init__()
+
+        self.time_value = dec(time_value).quantize(dec(".001"))
+
+        lay = QHBoxLayout(self)
+        lay.setSpacing(0)
+        lay.setContentsMargins(0, 0, 0, 0)
+
+        self.Stack = QStackedWidget()
+
+        self.w1 = Widget_hhmmss()
+        self.w1.time_changed_signal.connect(self.time_changed)
+        self.Stack.addWidget(self.w1)
+
+        self.w2 = Widget_seconds()
+        self.w2.time_changed_signal.connect(self.time_changed)
+        self.Stack.addWidget(self.w2)
+
+        lay.addWidget(self.Stack)
+
+        self.format_hhmmss = QRadioButton("HH:MM:SS:MS")
+        self.format_hhmmss.setChecked(True)
+        self.format_hhmmss.clicked.connect(self.set_format_hhmmss)
+        lay.addWidget(self.format_hhmmss)
+        self.format_s = QRadioButton("seconds")
+        self.format_s.clicked.connect(self.set_format_s)
+        lay.addWidget(self.format_s)
+
+        lay.addItem(QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
+
+        self.setLayout(lay)
+
+        self.set_time(self.time_value)
+
+    def time_changed(self, x):
+        """
+        widget time has changed
+        """
+        self.time_value = x
+
+    def set_time(self, new_time):
+        if new_time.is_nan():
+            return
+
+        self.w1.sign.setText("-" if new_time < 0 else "+")
+
+        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.w1.hours.setValue(h)
+        self.w1.minutes.setValue(m)
+        self.w1.seconds.setValue(s)
+        self.w1.milliseconds.setValue(ms)
+
+        self.w2.seconds2.setValue(new_time)
+
+        self.time_value = new_time
+
+    def set_format_s(self):
+        """
+        switch to seconds widget
+        """
+
+        self.format_s.setChecked(True)
+        self.w2.seconds2.setValue(self.time_value)
+        self.Stack.setCurrentIndex(1)
+
+    def set_format_hhmmss(self):
+        """
+        switch to HHMMSS widget
+        """
+
+        self.format_hhmmss.setChecked(True)
+        self.set_time(self.time_value)
+        self.Stack.setCurrentIndex(0)
+
+    def set_format(self, time_format):
+        """
+        switch time format in base of time_format value
+        """
+        if time_format in [cfg.HHMMSS, cfg.HHMMSSZZZ]:
+            self.set_format_hhmmss()
+        if time_format in [cfg.S]:
+            self.set_format_s()
+
+    def get_time(self) -> dec:
+        """
+        return time displayed by widget in seconds
+        """
+        return dec(self.time_value).quantize(dec(".001"))

boris/edit_event.py

@@ -0,0 +1,245 @@
+"""
+BORIS
+Behavioral Observation Research Interactive Software
+Copyright 2012-2025 Olivier Friard
+
+This file is part of BORIS.
+
+  BORIS 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 3 of the License, or
+  any later version.
+
+  BORIS 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 see <http://www.gnu.org/licenses/>.
+
+"""
+
+from decimal import Decimal as dec
+import logging
+
+from PySide6.QtWidgets import (
+    QDialog,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QListWidget,
+    QMessageBox,
+    QPushButton,
+    QRadioButton,
+    QVBoxLayout,
+)
+
+from . import config as cfg
+from . import dialog
+from .edit_event_ui import Ui_Form
+
+
+class DlgEditEvent(QDialog, Ui_Form):
+    def __init__(
+        self,
+        observation_type: str,
+        time_value: dec = dec("NaN"),
+        image_idx=None,
+        current_time=0,
+        time_format: str = cfg.S,
+        show_set_current_time: bool = False,
+        exif_date_time: dec | None = None,
+        parent=None,
+    ):
+        super().__init__(parent)
+        self.setupUi(self)
+        self.time_value = time_value
+        self.image_idx = image_idx
+        self.observation_type = observation_type
+
+        self.pb_set_to_current_time.setVisible(show_set_current_time)
+        self.current_time = current_time
+        self.exif_date_time = exif_date_time
+
+        # hide frame index for all observations
+        # frame index is determined in base of time
+        for w in (
+            self.lb_frame_idx,
+            self.sb_frame_idx,
+            self.cb_set_frame_idx_na,
+        ):
+            w.setVisible(False)
+
+        # hide image index
+        if observation_type in (cfg.LIVE, cfg.MEDIA):
+            # hide image index
+            for w in (
+                self.cb_set_time_na,
+                self.gb_image_index,
+            ):
+                w.setVisible(False)
+
+        # widget for time
+        self.time_widget = dialog.get_time_widget(self.time_value)
+
+        if time_format == cfg.S:
+            self.time_widget.rb_seconds.setChecked(True)
+        if time_format == cfg.HHMMSS:
+            self.time_widget.rb_time.setChecked(True)
+        if not self.time_value.is_nan() and int(self.time_value) > cfg.DATE_CUTOFF:
+            self.time_widget.rb_datetime.setChecked(True)
+
+        self.horizontalLayout_3.insertWidget(0, self.time_widget)
+
+        if observation_type == cfg.IMAGES:
+            # hide frame index widgets
+            self.pb_set_to_current_time.setVisible(self.exif_date_time is not None)
+            self.sb_image_idx.setValue(self.image_idx)
+
+        self.pb_set_to_current_time.clicked.connect(self.set_to_current_time)
+        self.pb_set_to_current_image_index.clicked.connect(self.set_to_current_image_index)
+
+        self.cb_set_time_na.stateChanged.connect(self.time_na)
+
+        # self.cb_set_frame_idx_na.stateChanged.connect(self.frame_idx_na)
+        self.pbOK.clicked.connect(self.close_widget)
+        self.pbCancel.clicked.connect(self.reject)
+
+    def close_widget(self):
+        """
+        close the widget
+        """
+        if self.observation_type in (cfg.IMAGES):
+            if self.sb_image_idx.value() == 0:
+                QMessageBox.warning(self, cfg.programName, "The image index cannot be null")
+                return
+        self.accept()
+
+    def set_to_current_image_index(self):
+        """
+        set image index to current image index
+        """
+        if self.observation_type in (cfg.IMAGES):
+            self.sb_image_idx.setValue(int(self.current_time))
+
+    def set_to_current_time(self):
+        """
+        set time to current media time
+        """
+
+        if self.observation_type in (cfg.LIVE, cfg.MEDIA):
+            self.time_widget.set_time(dec(float(self.current_time)))
+
+        if self.observation_type == cfg.IMAGES:
+            if self.exif_date_time is not None:
+                self.time_widget.set_time(dec(self.exif_date_time))
+
+    def time_na(self):
+        """
+        set/unset time to NA
+        """
+
+        logging.debug("time_na function")
+
+        self.time_widget.setVisible(not self.cb_set_time_na.isChecked())
+        self.time_widget.setEnabled(not self.cb_set_time_na.isChecked())
+
+        self.pb_set_to_current_time.setVisible(not self.cb_set_time_na.isChecked() and self.exif_date_time is not None)
+        self.pb_set_to_current_time.setEnabled(not self.cb_set_time_na.isChecked())
+
+
+class EditSelectedEvents(QDialog):
+    """
+    "edit selected events" dialog box
+    """
+
+    def __init__(self):
+        super(EditSelectedEvents, self).__init__()
+
+        self.setWindowTitle("Edit selected events")
+
+        hbox = QVBoxLayout(self)
+
+        self.rbSubject = QRadioButton("Subject")
+        self.rbSubject.setChecked(False)
+        self.rbSubject.toggled.connect(self.rb_changed)
+        hbox.addWidget(self.rbSubject)
+
+        self.rbBehavior = QRadioButton("Behavior")
+        self.rbBehavior.setChecked(False)
+        self.rbBehavior.toggled.connect(self.rb_changed)
+        hbox.addWidget(self.rbBehavior)
+
+        self.lb = QLabel("New value")
+        hbox.addWidget(self.lb)
+        self.newText = QListWidget(self)
+        hbox.addWidget(self.newText)
+
+        self.rbComment = QRadioButton("Comment")
+        self.rbComment.setChecked(False)
+        self.rbComment.toggled.connect(self.rb_changed)
+        hbox.addWidget(self.rbComment)
+
+        self.lbComment = QLabel("New comment")
+        hbox.addWidget(self.lbComment)
+
+        self.commentText = QLineEdit()
+        hbox.addWidget(self.commentText)
+
+        hbox2 = QHBoxLayout(self)
+        self.pbOK = QPushButton("OK")
+        self.pbOK.clicked.connect(self.pbOK_clicked)
+        self.pbCancel = QPushButton("Cancel")
+        self.pbCancel.clicked.connect(self.pbCancel_clicked)
+        hbox2.addWidget(self.pbCancel)
+        hbox2.addWidget(self.pbOK)
+        hbox.addLayout(hbox2)
+
+        self.setLayout(hbox)
+
+    def rb_changed(self):
+        self.newText.setEnabled(not self.rbComment.isChecked())
+        self.commentText.setEnabled(self.rbComment.isChecked())
+
+        if self.rbSubject.isChecked():
+            self.newText.clear()
+            self.newText.addItems(self.all_subjects)
+
+        if self.rbBehavior.isChecked():
+            self.newText.clear()
+            self.newText.addItems(self.all_behaviors)
+
+        if self.rbComment.isChecked():
+            self.newText.clear()
+
+    def pbOK_clicked(self):
+        """
+        if not self.rbSubject.isChecked() and not self.rbBehavior.isChecked() and not self.rbComment.isChecked():
+            QMessageBox.warning(
+                None,
+                cfg.programName,
+                "You must select a field to be edited",
+                QMessageBox.Ok | QMessageBox.Default,
+                QMessageBox.NoButton,
+            )
+            return
+        """
+
+        if (self.rbSubject.isChecked() or self.rbBehavior.isChecked()) and self.newText.selectedItems() == []:
+            QMessageBox.warning(
+                None,
+                cfg.programName,
+                "You must select a new value from the list",
+                QMessageBox.Ok | QMessageBox.Default,
+                QMessageBox.NoButton,
+            )
+            return
+
+        self.accept()
+
+    def pbCancel_clicked(self):
+        """
+        Cancel editing
+        """
+        self.reject()