boris-behav-obs 8.16.6__py3-none-any.whl → 9.7.1__py3-none-any.whl

boris/event_operations.py

@@ -1,7 +1,7 @@
 """
 BORIS
 Behavioral Observation Research Interactive Software
-Copyright 2012-2023 Olivier Friard
+Copyright 2012-2025 Olivier Friard
 
 
   This program is free software; you can redistribute it and/or modify
@@ -22,10 +22,13 @@ Copyright 2012-2023 Olivier Friard
 """
 
 import logging
+import copy
+import time
 from decimal import Decimal as dec
 from decimal import InvalidOperation
 from decimal import ROUND_DOWN
-from typing import Union, Optional, List, Tuple, Dict
+from typing import Union
+
 
 from . import config as cfg
 from . import utilities as util
@@ -35,8 +38,9 @@ from . import select_modifiers
 from . import write_event
 from .edit_event import DlgEditEvent, EditSelectedEvents
 
-from PyQt5.QtWidgets import QMessageBox, QInputDialog, QLineEdit, QAbstractItemView, QApplication
-from PyQt5.QtCore import QTime, Qt
+from PySide6.QtWidgets import QMessageBox, QInputDialog, QLineEdit, QAbstractItemView, QApplication
+from PySide6.QtCore import QTime, Qt
+from PySide6.QtGui import QClipboard
 
 
 def add_event(self):
@@ -50,11 +54,10 @@ def add_event(self):
 
     if self.pause_before_addevent:
         # pause media
-        if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.MEDIA:
-            if self.playerType == cfg.MEDIA:
-                memState = self.is_playing()
-                if memState:
-                    self.pause_video()
+        if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.MEDIA and self.playerType == cfg.MEDIA:
+            memState = self.is_playing()
+            if memState:
+                self.pause_video()
 
     if not self.pj[cfg.ETHOGRAM]:
         QMessageBox.warning(self, cfg.programName, "The ethogram is not set!")
@@ -67,7 +70,7 @@ def add_event(self):
 
     editWindow = DlgEditEvent(
         observation_type=self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE],
-        time_value=0,
+        time_value=dec("NaN"),
         image_idx=0,
         current_time=current_time,
         time_format=self.timeFormat,
@@ -75,10 +78,11 @@ def add_event(self):
     )
     editWindow.setWindowTitle("Add a new event")
 
-    sortedSubjects = [""] + sorted([self.pj[cfg.SUBJECTS][x][cfg.SUBJECT_NAME] for x in self.pj[cfg.SUBJECTS]])
+    sortedSubjects = [cfg.NO_FOCAL_SUBJECT] + sorted([self.pj[cfg.SUBJECTS][x][cfg.SUBJECT_NAME] for x in self.pj[cfg.SUBJECTS]])
 
     editWindow.cobSubject.addItems(sortedSubjects)
-    editWindow.cobSubject.setCurrentIndex(editWindow.cobSubject.findText(self.currentSubject, Qt.MatchFixedString))
+    if self.currentSubject:
+        editWindow.cobSubject.setCurrentIndex(editWindow.cobSubject.findText(self.currentSubject, Qt.MatchFixedString))
 
     sortedCodes = sorted([self.pj[cfg.ETHOGRAM][x][cfg.BEHAVIOR_CODE] for x in self.pj[cfg.ETHOGRAM]])
 
@@ -88,15 +92,33 @@ def add_event(self):
         # MEDIA / LIVE
         if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] in (cfg.MEDIA, cfg.LIVE):
             newTime = editWindow.time_widget.get_time()
+            if newTime is None:
+                QMessageBox.warning(
+                    self,
+                    cfg.programName,
+                    ("Select a time format"),
+                )
+                return
 
             for idx in self.pj[cfg.ETHOGRAM]:
                 if self.pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CODE] == editWindow.cobCode.currentText():
                     event = self.full_event(idx)
 
-                    event[cfg.SUBJECT] = editWindow.cobSubject.currentText()
+                    event[cfg.SUBJECT] = (
+                        "" if editWindow.cobSubject.currentText() == cfg.NO_FOCAL_SUBJECT else editWindow.cobSubject.currentText()
+                    )
                     if editWindow.leComment.toPlainText():
                         event[cfg.COMMENT] = editWindow.leComment.toPlainText()
 
+                    # determine the frame index
+                    if self.playerType == cfg.MEDIA:
+                        mem_time = self.getLaps()
+                        if not self.seek_mediaplayer(newTime):
+                            time.sleep(0.1)
+                            frame_idx = self.get_frame_index()
+                            event[cfg.FRAME_INDEX] = frame_idx
+                            self.seek_mediaplayer(mem_time)
+
                     write_event.write_event(self, event, newTime)
                     break
 
@@ -125,12 +147,17 @@ def add_event(self):
         # IMAGES
         if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.IMAGES:
             new_index = editWindow.sb_image_idx.value()
+            if new_index == 0:
+                QMessageBox.warning(self, cfg.programName, "The image index cannot be null")
+                return
 
             for idx in self.pj[cfg.ETHOGRAM]:
                 if self.pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CODE] == editWindow.cobCode.currentText():
                     event = self.full_event(idx)
 
-                    event[cfg.SUBJECT] = editWindow.cobSubject.currentText()
+                    event[cfg.SUBJECT] = (
+                        "" if editWindow.cobSubject.currentText() == cfg.NO_FOCAL_SUBJECT else editWindow.cobSubject.currentText()
+                    )
                     if editWindow.leComment.toPlainText():
                         event[cfg.COMMENT] = editWindow.leComment.toPlainText()
 
@@ -144,11 +171,13 @@ def add_event(self):
                     time_ = dec("NaN")
                     if self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.USE_EXIF_DATE, False):
                         if self.playerType != cfg.VIEWER_IMAGES:
-                            if self.extract_exif_DateTimeOriginal(self.images_list[new_index]) != -1:
-                                time_ = (
-                                    self.extract_exif_DateTimeOriginal(self.images_list[new_index])
-                                    - self.image_time_ref
-                                )
+                            exif_date_time = util.extract_exif_DateTimeOriginal(self.images_list[new_index])
+                            if exif_date_time != -1:
+                                time_ = exif_date_time
+
+                                # check if first value must be substracted
+                                if self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.SUBSTRACT_FIRST_EXIF_DATE, True):
+                                    time_ -= self.image_time_ref
 
                     elif self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.TIME_LAPSE, 0):
                         time_ = new_index * self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.TIME_LAPSE, 0)
@@ -171,13 +200,28 @@ def find_events(self):
 
     self.find_dialog = dialog.FindInEvents()
     # list of rows to find
-    self.find_dialog.rowsToFind = set([item.row() for item in self.twEvents.selectedIndexes()])
+    self.find_dialog.rowsToFind = set([self.tv_idx2events_idx[item.row()] for item in self.tv_events.selectedIndexes()])
     self.find_dialog.currentIdx = -1
     self.find_dialog.clickSignal.connect(self.click_signal_find_in_events)
     self.find_dialog.setWindowFlags(Qt.WindowStaysOnTopHint)
     self.find_dialog.show()
 
 
+def find_replace_events(self):
+    """
+    find and replace in events
+    """
+    fill_events_undo_list(self, "Undo Find/Replace operations")
+    self.find_replace_dialog = dialog.FindReplaceEvents()
+    self.find_replace_dialog.currentIdx = -1
+    self.find_replace_dialog.currentIdx_idx = -1
+    # list of rows to find/replace
+    self.find_replace_dialog.rowsToFind = set([self.tv_idx2events_idx[item.row()] for item in self.tv_events.selectedIndexes()])
+    self.find_replace_dialog.clickSignal.connect(self.click_signal_find_replace_in_events)
+    self.find_replace_dialog.setWindowFlags(Qt.WindowStaysOnTopHint)
+    self.find_replace_dialog.show()
+
+
 def filter_events(self):
     """
     filter coded events and subjects
@@ -186,11 +230,8 @@ def filter_events(self):
     parameters = select_subj_behav.choose_obs_subj_behav_category(
         self,
         selected_observations=[],  # empty selection of observations for selecting all subjects and behaviors
-        start_coding=dec("NaN"),
-        end_coding=dec("NaN"),
-        maxTime=None,
-        flagShowIncludeModifiers=False,
-        flagShowExcludeBehaviorsWoEvents=False,
+        show_include_modifiers=False,
+        show_exclude_non_coded_behaviors=False,
         by_category=False,
     )
     if parameters == {}:
@@ -221,7 +262,10 @@ def fill_events_undo_list(self, operation_description: str) -> None:
     """
     fill the undo events list for Undo function (CTRL + Z)
     """
-    self.undo_queue.append(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][:])
+    logging.debug("fill_events_undo_list function")
+
+    self.undo_queue.append(copy.deepcopy(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS]))
+
     self.undo_description.append(operation_description)
 
     self.actionUndo.setText(operation_description)
@@ -232,17 +276,22 @@ def fill_events_undo_list(self, operation_description: str) -> None:
     if len(self.undo_queue) > cfg.MAX_UNDO_QUEUE:
         self.undo_queue.popleft()
         self.undo_description.popleft()
-        logging.debug(f"Max events undo ")
+        logging.debug("Max events undo ")
 
 
 def undo_event_operation(self) -> None:
     """
     undo operation on event(s)
     """
+
+    logging.debug("Undo event operation function")
+
     if len(self.undo_queue) == 0:
-        self.statusbar.showMessage(f"The Undo buffer is empty", 5000)
+        self.statusbar.showMessage("The Undo buffer is empty", 5000)
         return
+
     events = self.undo_queue.pop()
+
     operation_description = self.undo_description.pop()
     self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS] = events[:]
     self.project_changed()
@@ -272,14 +321,14 @@ def delete_all_events(self):
         self.no_observation()
         return
 
-    if not self.twEvents.rowCount():
+    if not self.tv_idx2events_idx:
         QMessageBox.warning(self, cfg.programName, "No events to delete")
         return
 
     if (
         dialog.MessageDialog(
             cfg.programName,
-            ("Confirm the deletion of all (filtered) events in the current observation?<br>" "Filters do not apply!"),
+            ("Confirm the deletion of all (filtered) events in the current observation?<br>Filters do not apply!"),
             [cfg.YES, cfg.NO],
         )
         == cfg.YES
@@ -287,16 +336,10 @@ def delete_all_events(self):
         # fill the undo list
         fill_events_undo_list(self, "Undo 'Delete all events'")
 
-        rows_to_delete: list = []
-        for row in range(self.twEvents.rowCount()):
-            rows_to_delete.append(
-                self.twEvents.item(row, cfg.TW_OBS_FIELD[self.playerType][cfg.TIME]).data(Qt.UserRole)
-            )
-
         self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS] = [
             event
             for event_idx, event in enumerate(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS])
-            if event_idx not in rows_to_delete
+            if event_idx not in self.tv_idx2events_idx
         ]
 
         self.update_realtime_plot(force_plot=True)
@@ -316,7 +359,7 @@ def delete_selected_events(self):
 
     logging.debug("begin function delete_selected_events")
 
-    if not self.twEvents.selectedIndexes():
+    if not self.tv_events.selectedIndexes():
         QMessageBox.warning(self, cfg.programName, "No event selected!")
     else:
         # list of rows to delete (set for unique)
@@ -324,10 +367,8 @@ def delete_selected_events(self):
         fill_events_undo_list(self, "Undo 'Delete selected events'")
 
         rows_to_delete: list = []
-        for row in set([item.row() for item in self.twEvents.selectedIndexes()]):
-            rows_to_delete.append(
-                self.twEvents.item(row, cfg.TW_OBS_FIELD[self.playerType][cfg.TIME]).data(Qt.UserRole)
-            )
+        for row in set([item.row() for item in self.tv_events.selectedIndexes()]):
+            rows_to_delete.append(self.tv_idx2events_idx[row])
 
         self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS] = [
             event
@@ -364,7 +405,7 @@ def select_events_between_activated(self):
                 return None
         return timeSeconds
 
-    if not self.twEvents.rowCount():
+    if not self.tv_idx2events_idx:
         QMessageBox.warning(self, cfg.programName, "There are no events to select")
         return
 
@@ -396,15 +437,76 @@ def select_events_between_activated(self):
         if to_sec < from_sec:
             QMessageBox.critical(self, cfg.programName, "The initial time is greater than the final time")
             return
-        self.twEvents.clearSelection()
-        self.twEvents.setSelectionMode(QAbstractItemView.MultiSelection)
-        for r in range(self.twEvents.rowCount()):
-            if ":" in self.twEvents.item(r, cfg.TW_EVENTS_FIELDS[self.playerType][cfg.TIME]).text():
-                time = util.time2seconds(self.twEvents.item(r, cfg.TW_EVENTS_FIELDS[self.playerType][cfg.TIME]).text())
-            else:
-                time = dec(self.twEvents.item(r, cfg.TW_EVENTS_FIELDS[self.playerType][cfg.TIME]).text())
+
+        self.tv_events.clearSelection()
+        self.tv_events.setSelectionMode(QAbstractItemView.MultiSelection)
+
+        # for r in range(self.tv_events.rowCount()):
+        # for idx, event in enumerate(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS]):
+        for tv_idx in range(len(self.tv_idx2events_idx)):
+            time = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][self.tv_idx2events_idx[tv_idx]][
+                cfg.PJ_OBS_FIELDS[self.playerType][cfg.TIME]
+            ]
+
             if from_sec <= time <= to_sec:
-                self.twEvents.selectRow(r)
+                self.tv_events.selectRow(tv_idx)
+
+        self.tv_events.setSelectionMode(QAbstractItemView.ExtendedSelection)
+
+
+def add_comment(self):
+    """
+    add a comment to the selected events
+    operation can be undone with Undo
+    """
+    tvevents_rows_to_edit = set([index.row() for index in self.tv_events.selectionModel().selectedIndexes()])
+    if not len(tvevents_rows_to_edit):
+        QMessageBox.warning(self, cfg.programName, "No event selected!")
+        return
+
+    comment_str: str = ""
+    if len(tvevents_rows_to_edit) == 1:
+        pj_event_idx = self.tv_idx2events_idx[self.tv_events.selectionModel().selectedIndexes()[0].row()]
+        comment_str = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][
+            cfg.PJ_OBS_FIELDS[self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE]][cfg.COMMENT]
+        ]
+    else:
+        # check if comment is the same in all selected events
+
+        if (
+            len(
+                set(
+                    [
+                        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][self.tv_idx2events_idx[tvevents_row]][
+                            cfg.PJ_OBS_FIELDS[self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE]][cfg.COMMENT]
+                        ]
+                        for tvevents_row in tvevents_rows_to_edit
+                    ]
+                )
+            )
+            == 1
+        ):
+            pj_event_idx = self.tv_idx2events_idx[self.tv_events.selectionModel().selectedIndexes()[0].row()]
+            comment_str = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][
+                cfg.PJ_OBS_FIELDS[self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE]][cfg.COMMENT]
+            ]
+
+    new_comment, ok = QInputDialog.getText(self, "Add/Edit a comment", "Comment:", text=comment_str)
+    if not ok:
+        return
+
+    # fill the undo list
+    fill_events_undo_list(self, "Undo last comment operation")
+
+    for tvevents_row in tvevents_rows_to_edit:
+        pj_event_idx = self.tv_idx2events_idx[tvevents_row]
+
+        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][
+            cfg.PJ_OBS_FIELDS[self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE]][cfg.COMMENT]
+        ] = new_comment
+
+    # reload all events in tw
+    self.load_tw_events(self.observationId)
 
 
 def edit_selected_events(self):
@@ -412,56 +514,46 @@ def edit_selected_events(self):
     edit one or more selected events for subject, behavior and/or comment
     """
     # list of rows to edit
-    twEvents_rows_to_edit = set([item.row() for item in self.twEvents.selectedIndexes()])
 
-    if not len(twEvents_rows_to_edit):
+    tvevents_rows_to_edit = set([index.row() for index in self.tv_events.selectionModel().selectedIndexes()])
+
+    if not len(tvevents_rows_to_edit):
         QMessageBox.warning(self, cfg.programName, "No event selected!")
-    elif len(twEvents_rows_to_edit) == 1:  # 1 event selected
+
+    elif len(tvevents_rows_to_edit) == 1:  # 1 event selected
         edit_event(self)
+
     else:  # editing of more events
-        dialogWindow = EditSelectedEvents()
-        dialogWindow.all_behaviors = sorted(
-            [self.pj[cfg.ETHOGRAM][x][cfg.BEHAVIOR_CODE] for x in self.pj[cfg.ETHOGRAM]]
-        )
+        dialog_window = EditSelectedEvents()
+        dialog_window.all_behaviors = sorted([self.pj[cfg.ETHOGRAM][x][cfg.BEHAVIOR_CODE] for x in self.pj[cfg.ETHOGRAM]])
 
-        dialogWindow.all_subjects = [
-            self.pj[cfg.SUBJECTS][str(k)][cfg.SUBJECT_NAME]
-            for k in sorted([int(x) for x in self.pj[cfg.SUBJECTS].keys()])
+        dialog_window.all_subjects = [cfg.NO_FOCAL_SUBJECT] + [
+            self.pj[cfg.SUBJECTS][str(k)][cfg.SUBJECT_NAME] for k in sorted([int(x) for x in self.pj[cfg.SUBJECTS].keys()])
         ]
 
-        if dialogWindow.exec_():
+        if dialog_window.exec_():
             # fill the undo list
             fill_events_undo_list(self, "Undo 'Edit selected event(s)'")
 
             tsb_to_edit: list = []
-            for row in twEvents_rows_to_edit:
-                tsb_to_edit.append(
-                    self.twEvents.item(row, cfg.TW_OBS_FIELD[self.playerType][cfg.TIME]).data(Qt.UserRole)
-                )
-                """
-                tsb_to_edit.append(
-                    [
-                        util.time2seconds(self.read_tw_event_field(row, self.playerType, cfg.TIME))
-                        if self.timeFormat == cfg.HHMMSS
-                        else dec(self.read_tw_event_field(row, self.playerType, cfg.TIME)),
-                        self.read_tw_event_field(row, self.playerType, cfg.SUBJECT),
-                        self.read_tw_event_field(row, self.playerType, cfg.BEHAVIOR_CODE),
-                    ]
-                )
-                """
+            for row in tvevents_rows_to_edit:
+                tsb_to_edit.append(self.tv_idx2events_idx[row])
 
-            behavior_codes = []
-            modifiers_mem = []
-            mem_event_idx = []
+            behavior_codes: list = []
+            modifiers_mem: list = []
+            mem_event_idx: list = []
             for idx, event in enumerate(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS]):
                 if idx in tsb_to_edit:
                     new_event = list(event)
-                    if dialogWindow.rbSubject.isChecked():
-                        new_event[cfg.EVENT_SUBJECT_FIELD_IDX] = dialogWindow.newText.selectedItems()[0].text()
-                    if dialogWindow.rbBehavior.isChecked():
-                        new_event[cfg.EVENT_BEHAVIOR_FIELD_IDX] = dialogWindow.newText.selectedItems()[0].text()
-                    if dialogWindow.rbComment.isChecked():
-                        new_event[cfg.EVENT_COMMENT_FIELD_IDX] = dialogWindow.commentText.text()
+                    if dialog_window.rbSubject.isChecked():
+                        if dialog_window.newText.selectedItems()[0].text() == cfg.NO_FOCAL_SUBJECT:
+                            new_event[cfg.EVENT_SUBJECT_FIELD_IDX] = ""
+                        else:
+                            new_event[cfg.EVENT_SUBJECT_FIELD_IDX] = dialog_window.newText.selectedItems()[0].text()
+                    if dialog_window.rbBehavior.isChecked():
+                        new_event[cfg.EVENT_BEHAVIOR_FIELD_IDX] = dialog_window.newText.selectedItems()[0].text()
+                    if dialog_window.rbComment.isChecked():
+                        new_event[cfg.EVENT_COMMENT_FIELD_IDX] = dialog_window.commentText.text()
 
                     if new_event[cfg.EVENT_BEHAVIOR_FIELD_IDX] not in behavior_codes:
                         behavior_codes.append(new_event[cfg.EVENT_BEHAVIOR_FIELD_IDX])
@@ -490,9 +582,7 @@ def edit_selected_events(self):
                     current_modifier = ""
 
                 if event["modifiers"]:
-                    modifiers_selector = select_modifiers.ModifiersList(
-                        behavior_codes[0], eval(str(event["modifiers"])), current_modifier
-                    )
+                    modifiers_selector = select_modifiers.ModifiersList(behavior_codes[0], eval(str(event["modifiers"])), current_modifier)
 
                     r = modifiers_selector.exec_()
                     if r:
@@ -513,9 +603,7 @@ def edit_selected_events(self):
                 # set new modifier
                 for idx, event in enumerate(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS]):
                     if idx in mem_event_idx:
-                        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][idx][
-                            cfg.EVENT_MODIFIER_FIELD_IDX
-                        ] = modifier_str
+                        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][idx][cfg.EVENT_MODIFIER_FIELD_IDX] = modifier_str
 
             self.load_tw_events(self.observationId)
 
@@ -524,20 +612,27 @@ def edit_selected_events(self):
 
 def edit_event(self):
     """
-    edit event corresponding to the selected row in twEvents
+    edit event corresponding to the selected row in tv_events
     """
 
     if not self.observationId:
         self.no_observation()
         return
 
-    if not self.twEvents.selectedItems():
+    if not self.tv_events.selectionModel().selectedIndexes():
         QMessageBox.warning(self, cfg.programName, "Select an event to edit")
         return
 
-    twEvents_row = self.twEvents.selectedItems()[0].row()
+    if self.pause_before_addevent:
+        # pause media
+        if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.MEDIA and self.playerType == cfg.MEDIA:
+            player_mem_state = self.is_playing()
+            if player_mem_state:
+                self.pause_video()
+
+    tvevents_row = self.tv_events.selectionModel().selectedIndexes()[0].row()
 
-    pj_event_idx = self.twEvents.item(twEvents_row, cfg.TW_OBS_FIELD[self.playerType][cfg.TIME]).data(Qt.UserRole)
+    pj_event_idx = self.tv_idx2events_idx[tvevents_row]
 
     time_value = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][
         cfg.PJ_OBS_FIELDS[self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE]][cfg.TIME]
@@ -549,138 +644,159 @@ def edit_event(self):
             cfg.PJ_OBS_FIELDS[self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE]][cfg.IMAGE_INDEX]
         ]
 
-    """
-    elif self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] in (cfg.LIVE, cfg.MEDIA):
-        value = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][
-            cfg.PJ_OBS_FIELDS[self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE]][cfg.TIME]
-        ]
-    else:
-        QMessageBox.warning(
-            self,
-            cfg.programName,
-            f"Observation type {self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE]} not recognized",
-        )
-        return
-    """
-
     if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.IMAGES:
         current_value = self.image_idx + 1
     else:
         current_value = self.getLaps()
 
-    editWindow = DlgEditEvent(
+    # get exif date time
+    if self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.USE_EXIF_DATE, False):
+        exif_date_time = util.extract_exif_DateTimeOriginal(self.images_list[self.image_idx])
+    else:
+        exif_date_time = None
+
+    edit_window = DlgEditEvent(
         observation_type=self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE],
         time_value=time_value,
         image_idx=image_idx,
         current_time=current_value,
         time_format=self.timeFormat,
         show_set_current_time=True,
+        exif_date_time=exif_date_time,
     )
-    editWindow.setWindowTitle("Edit event")
-
-    #
-    if self.playerType in (cfg.VIEWER_MEDIA, cfg.VIEWER_LIVE, cfg.VIEWER_IMAGES):
-        editWindow.pb_set_to_current_time.setVisible(False)
-
-    sortedSubjects = [""] + sorted([self.pj[cfg.SUBJECTS][x][cfg.SUBJECT_NAME] for x in self.pj[cfg.SUBJECTS]])
+    edit_window.setWindowTitle("Edit event")
 
-    editWindow.cobSubject.addItems(sortedSubjects)
+    # time
+    if time_value.is_nan():
+        edit_window.cb_set_time_na.setChecked(True)
 
-    if (
-        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_SUBJECT_FIELD_IDX]
-        in sortedSubjects
-    ):
-        editWindow.cobSubject.setCurrentIndex(
-            sortedSubjects.index(
-                self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_SUBJECT_FIELD_IDX]
-            )
+    # remove visibility of 'set current time' widget if VIEWER mode
+    if self.playerType in (cfg.VIEWER_MEDIA, cfg.VIEWER_LIVE, cfg.VIEWER_IMAGES):
+        edit_window.pb_set_to_current_time.setVisible(False)
+
+    # subjects
+    sorted_subjects = [cfg.NO_FOCAL_SUBJECT] + sorted([self.pj[cfg.SUBJECTS][x][cfg.SUBJECT_NAME] for x in self.pj[cfg.SUBJECTS]])
+    edit_window.cobSubject.addItems(sorted_subjects)
+    if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_SUBJECT_FIELD_IDX] == "":  # no focal subject
+        edit_window.cobSubject.setCurrentIndex(sorted_subjects.index(cfg.NO_FOCAL_SUBJECT))
+    elif self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_SUBJECT_FIELD_IDX] in sorted_subjects:
+        edit_window.cobSubject.setCurrentIndex(
+            sorted_subjects.index(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_SUBJECT_FIELD_IDX])
         )
     else:
         QMessageBox.warning(
             self,
             cfg.programName,
             (
-                f"The subject <b>{self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_SUBJECT_FIELD_IDX]}</b> "
+                "The subject "
+                f"<b>{self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_SUBJECT_FIELD_IDX]}</b> "
                 "does not exist more in the subject's list"
             ),
         )
-        editWindow.cobSubject.setCurrentIndex(0)
+        edit_window.cobSubject.setCurrentIndex(0)
 
+    # behaviors
     sortedCodes = sorted([self.pj[cfg.ETHOGRAM][x][cfg.BEHAVIOR_CODE] for x in self.pj[cfg.ETHOGRAM]])
-    editWindow.cobCode.addItems(sortedCodes)
-
+    edit_window.cobCode.addItems(sortedCodes)
     # check if selected code is in code's list (no modification of codes)
-    if (
-        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_BEHAVIOR_FIELD_IDX]
-        in sortedCodes
-    ):
-        editWindow.cobCode.setCurrentIndex(
-            sortedCodes.index(
-                self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_BEHAVIOR_FIELD_IDX]
-            )
+    if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_BEHAVIOR_FIELD_IDX] in sortedCodes:
+        edit_window.cobCode.setCurrentIndex(
+            sortedCodes.index(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_BEHAVIOR_FIELD_IDX])
         )
     else:
-        logging.warning(
-            (
-                f"The behaviour {self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_BEHAVIOR_FIELD_IDX]} "
-                "does not exist more in the ethogram"
-            )
+        msg: str = (
+            f"The behaviour {self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_BEHAVIOR_FIELD_IDX]} "
+            "does not exist longer in the ethogram"
         )
+        logging.warning(msg)
+
         QMessageBox.warning(
             self,
             cfg.programName,
-            (
-                f"The behaviour <b>{self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_BEHAVIOR_FIELD_IDX]}</b> "
-                "does not exist more in the ethogram"
-            ),
+            msg,
         )
-        editWindow.cobCode.setCurrentIndex(0)
+        edit_window.cobCode.setCurrentIndex(0)
 
     logging.debug(
         f"original modifiers: {self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_MODIFIER_FIELD_IDX]}"
     )
 
-    # frame index
-    frame_idx = read_event_field(
-        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx],
-        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE],
-        cfg.FRAME_INDEX,
-    )
-    editWindow.sb_frame_idx.setValue(0 if frame_idx in (cfg.NA, None) else frame_idx)
-    if frame_idx in (cfg.NA, None):
-        editWindow.cb_set_frame_idx_na.setChecked(True)
+    # # frame index
+    # frame_idx = read_event_field(
+    #     self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx],
+    #     self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE],
+    #     cfg.FRAME_INDEX,
+    # )
+    # edit_window.sb_frame_idx.setValue(0 if frame_idx in (cfg.NA, None) else frame_idx)
+    # if frame_idx in (cfg.NA, None):
+    #     edit_window.cb_set_frame_idx_na.setChecked(True)
 
     # comment
-    editWindow.leComment.setPlainText(
-        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_COMMENT_FIELD_IDX]
-    )
+    edit_window.leComment.setPlainText(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.EVENT_COMMENT_FIELD_IDX])
 
     flag_ok = False  # for looping until event is OK or Cancel pressed
     while True:
-        if editWindow.exec_():  # button OK
+        if edit_window.exec():  # button OK
             self.project_changed()
 
+            new_time = edit_window.time_widget.get_time()
+
+            if edit_window.cb_set_time_na.isChecked():
+                new_time = dec("NaN")
+
             # MEDIA / LIVE
             if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] in (cfg.MEDIA, cfg.LIVE):
-                new_time = editWindow.time_widget.get_time()
+                if new_time.is_nan():
+                    QMessageBox.warning(
+                        self,
+                        cfg.programName,
+                        ("Select a time format"),
+                    )
+                    continue
+
                 for key in self.pj[cfg.ETHOGRAM]:
-                    if self.pj[cfg.ETHOGRAM][key][cfg.BEHAVIOR_CODE] == editWindow.cobCode.currentText():
+                    if self.pj[cfg.ETHOGRAM][key][cfg.BEHAVIOR_CODE] == edit_window.cobCode.currentText():
                         event = self.full_event(key)
-                        event[cfg.SUBJECT] = editWindow.cobSubject.currentText()
-                        event[cfg.COMMENT] = editWindow.leComment.toPlainText()
+                        # subject
+                        event[cfg.SUBJECT] = (
+                            "" if edit_window.cobSubject.currentText() == cfg.NO_FOCAL_SUBJECT else edit_window.cobSubject.currentText()
+                        )
 
+                        event[cfg.COMMENT] = edit_window.leComment.toPlainText()
+
+                        # determine the new frame index
                         if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.MEDIA:
-                            if not editWindow.sb_frame_idx.value() or editWindow.cb_set_frame_idx_na.isChecked():
-                                event[cfg.FRAME_INDEX] = cfg.NA
-                            else:
-                                event[cfg.FRAME_INDEX] = editWindow.sb_frame_idx.value()
+                            if self.playerType == cfg.MEDIA:
+                                mem_time = self.getLaps()
+                                if not self.seek_mediaplayer(new_time):
+                                    time.sleep(0.1)
+                                    frame_idx = self.get_frame_index()
+                                    event[cfg.FRAME_INDEX] = frame_idx
+                                    self.seek_mediaplayer(mem_time)
+
+                            # if not edit_window.sb_frame_idx.value() or edit_window.cb_set_frame_idx_na.isChecked():
+                            #     event[cfg.FRAME_INDEX] = cfg.NA
+                            # else:
+                            #     if self.playerType == cfg.MEDIA:
+                            #         mem_time = self.getLaps()
+                            #         if not self.seek_mediaplayer(new_time):
+                            #             frame_idx = self.get_frame_index()
+                            #             event[cfg.FRAME_INDEX] = frame_idx
+                            #             self.seek_mediaplayer(mem_time)
+                            #
+                            #     # event[cfg.FRAME_INDEX] = edit_window.sb_frame_idx.value()
 
                         event["row"] = pj_event_idx
-                        event["original_modifiers"] = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][
-                            pj_event_idx
-                        ][cfg.PJ_OBS_FIELDS[self.playerType][cfg.MODIFIER]]
+                        event["original_modifiers"] = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][
+                            cfg.PJ_OBS_FIELDS[self.playerType][cfg.MODIFIER]
+                        ]
 
                         r = write_event.write_event(self, event, new_time)
+
+                        # scroll tv events
+                        index = self.tv_events.model().index(pj_event_idx, 0)
+                        self.tv_events.scrollTo(index, QAbstractItemView.EnsureVisible)
+
                         if r == 1:  # same event already present
                             continue
                         if not r:
@@ -691,22 +807,21 @@ def edit_event(self):
 
             # IMAGES
             if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.IMAGES:
-                new_index = editWindow.sb_image_idx.value()
+                new_index = edit_window.sb_image_idx.value()
 
                 for key in self.pj[cfg.ETHOGRAM]:
-                    if self.pj[cfg.ETHOGRAM][key][cfg.BEHAVIOR_CODE] == editWindow.cobCode.currentText():
+                    if self.pj[cfg.ETHOGRAM][key][cfg.BEHAVIOR_CODE] == edit_window.cobCode.currentText():
                         event = self.full_event(key)
-                        if editWindow.time_value == cfg.NA or (editWindow.cb_set_time_na.isChecked()):
-                            event[cfg.TIME] = dec("NaN")
-                        else:
-                            event[cfg.TIME] = editWindow.time_widget.get_time()
+                        event[cfg.TIME] = new_time
 
-                        event[cfg.SUBJECT] = editWindow.cobSubject.currentText()
-                        event[cfg.COMMENT] = editWindow.leComment.toPlainText()
+                        event[cfg.SUBJECT] = (
+                            "" if edit_window.cobSubject.currentText() == cfg.NO_FOCAL_SUBJECT else edit_window.cobSubject.currentText()
+                        )
+                        event[cfg.COMMENT] = edit_window.leComment.toPlainText()
                         event["row"] = pj_event_idx
-                        event["original_modifiers"] = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][
-                            pj_event_idx
-                        ][cfg.PJ_OBS_FIELDS[self.playerType][cfg.MODIFIER]]
+                        event["original_modifiers"] = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][
+                            cfg.PJ_OBS_FIELDS[self.playerType][cfg.MODIFIER]
+                        ]
 
                         # not editable yet. Read previous value
                         event[cfg.IMAGE_PATH] = read_event_field(
@@ -715,32 +830,9 @@ def edit_event(self):
                             cfg.IMAGE_PATH,
                         )
 
-                        """
-                        try:
-                            event[cfg.IMAGE_PATH] = self.images_list[new_index]
-                        except IndexError:
-                            event[cfg.IMAGE_PATH] = ""
-                        """
                         event[cfg.IMAGE_INDEX] = new_index
 
-                        """
-                        time_ = dec("NaN")
-                        if (
-                            self.playerType != cfg.VIEWER_IMAGES
-                            and self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.USE_EXIF_DATE, False)
-                            and self.extract_exif_DateTimeOriginal(self.images_list[new_index]) != -1
-                        ):
-                            time_ = (
-                                self.extract_exif_DateTimeOriginal(self.images_list[new_index]) - self.image_time_ref
-                            )
-
-                        elif self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.TIME_LAPSE, 0):
-                            time_ = new_index * self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.TIME_LAPSE, 0)
-                        """
-
-                        r = write_event.write_event(
-                            self, event, event[cfg.TIME].quantize(dec("0.001"), rounding=ROUND_DOWN)
-                        )
+                        r = write_event.write_event(self, event, event[cfg.TIME].quantize(dec("0.001"), rounding=ROUND_DOWN))
                         if r == 1:  # same event already present
                             continue
                         if not r:
@@ -753,78 +845,81 @@ def edit_event(self):
         if flag_ok:
             break
 
+    if self.pause_before_addevent:
+        # restart media
+        if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.MEDIA and self.playerType == cfg.MEDIA:
+            if player_mem_state:
+                self.play_video()
+
 
 def edit_time_selected_events(self):
     """
-    edit time of one or more selected events
+    shift time of one or more selected events
     """
-    # list of rows to edit
-    twEvents_rows_to_shift = set([item.row() for item in self.twEvents.selectedIndexes()])
 
-    if not len(twEvents_rows_to_shift):
+    tvevents_rows_to_shift = set([index.row() for index in self.tv_events.selectionModel().selectedIndexes()])
+    if not len(tvevents_rows_to_shift):
         QMessageBox.warning(self, cfg.programName, "No event selected!")
         return
 
-    d, ok = QInputDialog.getDouble(
-        self, "Time value", "Value to add or substract (use negative value):", 0, -86400, 86400, 3
-    )
-    if ok and d:
-        if (
-            dialog.MessageDialog(
-                cfg.programName,
-                (
-                    f"Confirm the {'addition' if d > 0 else 'subtraction'} of {abs(d)} seconds "
-                    "to all selected events in the current observation?"
-                ),
-                [cfg.YES, cfg.NO],
-            )
-            == cfg.NO
-        ):
-            return
+    w = dialog.Ask_time(0)
+    w.setWindowTitle("Shift time of selected event(s)")
+    w.label.setText("Amount of time to add or substract")
 
-        # fill the undo list
-        fill_events_undo_list(self, "Undo 'Edit time'")
+    if not w.exec_():
+        return
 
-        for tw_event_idx in twEvents_rows_to_shift:
-            pj_event_idx = self.twEvents.item(tw_event_idx, cfg.TW_OBS_FIELD[self.playerType][cfg.TIME]).data(
-                Qt.UserRole
-            )
-            self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][
-                cfg.PJ_OBS_FIELDS[self.playerType][cfg.TIME]
-            ] += dec(f"{d:.3f}")
-            self.project_changed()
+    d = w.time_widget.get_time()
+    if d.is_nan() or not d:
+        return
+
+    if ":" in util.smart_time_format(abs(d)):
+        smart_d = f"{util.smart_time_format(abs(d))}"
+    else:
+        smart_d = f"{d} seconds"
 
-        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS] = sorted(
-            self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS]
+    if (
+        dialog.MessageDialog(
+            cfg.programName,
+            (f"Confirm the {'addition' if d > 0 else 'subtraction'} of {smart_d} to all selected events in the current observation?"),
+            [cfg.YES, cfg.NO],
         )
-        self.load_tw_events(self.observationId)
+        == cfg.NO
+    ):
+        return
 
-        self.update_realtime_plot(force_plot=True)
+    # fill the undo list
+    fill_events_undo_list(self, "Undo 'Edit time'")
 
+    mem_time = self.getLaps()
+    for tw_event_idx in tvevents_rows_to_shift:
+        pj_event_idx = self.tv_idx2events_idx[tw_event_idx]
 
-'''
-def copy_selected_events(self):
-    """
-    copy selected events to clipboard
-    """
-    twEvents_rows_to_copy = set([item.row() for item in self.twEvents.selectedIndexes()])
-    if not len(twEvents_rows_to_copy):
-        QMessageBox.warning(self, cfg.programName, "No event selected!")
-        return
+        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.PJ_OBS_FIELDS[self.playerType][cfg.TIME]] += dec(
+            f"{d:.3f}"
+        )
+        # set new frame index
+        if self.playerType == cfg.MEDIA:
+            if not self.seek_mediaplayer(
+                self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][cfg.PJ_OBS_FIELDS[self.playerType][cfg.TIME]]
+            ):
+                # determine the new frame index
+                time.sleep(0.1)
+                frame_idx = self.get_frame_index()
+                if len(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx]) == 6:
+                    self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][-1] = frame_idx
+                elif len(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx]) == 5:
+                    self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx].append(frame_idx)
 
-    tsb_to_copy: list = []
-    for row in twEvents_rows_to_copy:
-        tsb_to_copy.append(self.twEvents.item(row, cfg.TW_OBS_FIELD[self.playerType][cfg.TIME]).data(Qt.UserRole))
+        self.project_changed()
 
-    copied_events: list = []
-    for idx, event in enumerate(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS]):
-        if idx in tsb_to_copy:
-            copied_events.append("\t".join([str(x) for x in event]))
+    if self.playerType == cfg.MEDIA:
+        self.seek_mediaplayer(mem_time)
 
-    cb = QApplication.clipboard()
-    cb.clear(mode=cb.Clipboard)
-    cb.setText("\n".join(copied_events), mode=cb.Clipboard)
-'''
+    self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS] = sorted(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS])
+    self.load_tw_events(self.observationId)
+
+    self.update_realtime_plot(force_plot=True)
 
 
 def copy_selected_events(self):
@@ -834,16 +929,12 @@ def copy_selected_events(self):
 
     logging.debug("Copy selected events to clipboard")
 
-    twEvents_rows_to_copy = set([item.row() for item in self.twEvents.selectedIndexes()])
-    if not len(twEvents_rows_to_copy):
+    tvevents_rows_to_copy = set([index.row() for index in self.tv_events.selectionModel().selectedIndexes()])
+    if not len(tvevents_rows_to_copy):
         QMessageBox.warning(self, cfg.programName, "No event selected!")
         return
 
-    pj_event_idx_to_copy: list = []
-    for row in twEvents_rows_to_copy:
-        pj_event_idx_to_copy.append(
-            self.twEvents.item(row, cfg.TW_OBS_FIELD[self.playerType][cfg.TIME]).data(Qt.UserRole)
-        )
+    pj_event_idx_to_copy: list = [self.tv_idx2events_idx[row] for row in tvevents_rows_to_copy]
 
     copied_events: list = []
     for idx, event in enumerate(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS]):
@@ -854,8 +945,8 @@ def copy_selected_events(self):
                 copied_events.append("\t".join([str(x) for x in event]))
 
     cb = QApplication.clipboard()
-    cb.clear(mode=cb.Clipboard)
-    cb.setText("\n".join(copied_events), mode=cb.Clipboard)
+    cb.clear(mode=QClipboard.Mode.Clipboard)
+    cb.setText("\n".join(copied_events), mode=QClipboard.Mode.Clipboard)
 
     logging.debug("Selected events copied in clipboard")
 
@@ -870,24 +961,35 @@ def paste_clipboard_to_events(self):
     cb_text_splitted = cb_text.split("\n")
     length: list = []
     content: list = []
-    for l in cb_text_splitted:
-        length.append(len(l.split("\t")))
-        content.append(l.split("\t"))
+    for line in cb_text_splitted:
+        length.append(len(line.split("\t")))
+        content.append(line.split("\t"))
 
     if set(length) != set([len(cfg.PJ_EVENTS_FIELDS[self.playerType])]):
-        QMessageBox.warning(
-            self,
+        msg_box = QMessageBox(
+            QMessageBox.Warning,
             cfg.programName,
             (
-                "The clipboard does not contain events!\n"
+                "The clipboard does not contain events!<br>"
                 f"For an observation from <b>{self.playerType}</b> "
-                f"the events must be organized in {len(cfg.PJ_EVENTS_FIELDS[self.playerType])} columns separated by TAB character"
+                f"the events must be organized in {len(cfg.PJ_EVENTS_FIELDS[self.playerType])} columns separated by <TAB> character"
             ),
         )
+        msg_box.setWindowFlags(msg_box.windowFlags() | Qt.WindowStaysOnTopHint)
+        msg_box.exec()
+
         return
 
     for event in content:
+        # convert time in decimal
         event[cfg.EVENT_TIME_FIELD_IDX] = dec(event[cfg.EVENT_TIME_FIELD_IDX])
+        for idx, _ in enumerate(event):
+            if cfg.PJ_EVENTS_FIELDS[self.playerType][idx] in (cfg.FRAME_INDEX, cfg.IMAGE_INDEX):
+                try:
+                    event[idx] = int(event[idx])
+                except ValueError:
+                    pass
+
         # skip if event already present
         if event in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS]:
             continue
@@ -896,9 +998,7 @@ def paste_clipboard_to_events(self):
 
         self.project_changed()
 
-    self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS] = sorted(
-        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS]
-    )
+    self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS] = sorted(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS])
     self.load_tw_events(self.observationId)
 
     self.update_realtime_plot(force_plot=True)
@@ -914,3 +1014,27 @@ def read_event_field(event: list, player_type: str, field_type: str) -> Union[st
         return event[cfg.PJ_OBS_FIELDS[player_type][field_type]]
     else:
         return cfg.NA
+
+
+def add_frame_indexes(self):
+    """
+    add frame indexes for all events
+    """
+    if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] != cfg.MEDIA:
+        return
+    if self.playerType != cfg.MEDIA:
+        return
+
+    mem_time = self.getLaps()
+    for idx, event in enumerate(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS]):
+        if event[0] == "NA":
+            continue
+        if not self.seek_mediaplayer(event[0]):
+            time.sleep(0.1)
+            self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][idx][cfg.PJ_OBS_FIELDS[cfg.MEDIA][cfg.FRAME_INDEX]] = (
+                self.get_frame_index()
+            )
+
+    self.seek_mediaplayer(mem_time)
+
+    self.load_tw_events(self.observationId)