tracktags UI mwe

bin/ffx/model/track.py

@@ -154,7 +154,10 @@ class Track(Base):
     
     def getType(self):
         return TrackType.fromIndex(self.track_type)
-    
+
+    # def getIndex(self):
+    #     return int(self.index)
+
     def getSubIndex(self):
         return int(self.sub_index)
     
@@ -171,3 +174,20 @@ class Track(Base):
     
     def getTags(self):
         return {str(t.key):str(t.value) for t in self.track_tags}
+
+
+    def getDescriptor(self) -> TrackDescriptor:
+
+        kwargs = {}
+
+        kwargs[TrackDescriptor.ID_KEY] = self.getId()
+        kwargs[TrackDescriptor.PATTERN_ID_KEY] = self.getPatternId()
+
+        #kwargs[TrackDescriptor.SUB_INDEX_KEY] = self.getIndex()
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = self.getSubIndex()
+
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = self.getType()
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = self.getDispositionSet()
+        kwargs[TrackDescriptor.TAGS_KEY] = self.getTags()
+
+        return TrackDescriptor(**kwargs)

bin/ffx/pattern_details_screen.py

@@ -80,7 +80,7 @@ class PatternDetailsScreen(Screen):
         self.__sc = ShowController(context = self.context)
         self.__tc = TrackController(context = self.context)
 
-        self.__pattern = self.__pc.getPattern(patternId) if patternId is not None else None
+        self.__pattern : Pattern = self.__pc.getPattern(patternId) if patternId is not None else None
 
         self.show_obj = self.__sc.getShowDesciptor(showId) if showId is not None else {}
 
@@ -270,18 +270,7 @@ class PatternDetailsScreen(Screen):
 
                 subIndex = int(selected_track_data[0])
 
-                audioTrack =  self.__tc.findTrack(self.__pattern.getId(), TrackType.AUDIO, subIndex)
+                return self.__tc.findTrack(self.__pattern.getId(), TrackType.AUDIO, subIndex).getDescriptor()
-
-                kwargs = {}
-
-                kwargs[TrackDescriptor.PATTERN_ID_KEY] = self.__pattern.getId()
-                kwargs[TrackDescriptor.SUB_INDEX_KEY] = subIndex
-
-                kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-                kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioTrack.getDispositionSet()
-                kwargs[TrackDescriptor.TAGS_KEY] = audioTrack.getTags()
-
-                return TrackDescriptor(**kwargs)
 
             else:
                 return None
@@ -290,7 +279,7 @@ class PatternDetailsScreen(Screen):
             return None
 
 
-    def getSelectedSubtitleTrackDescriptor(self):
+    def getSelectedSubtitleTrackDescriptor(self) -> TrackDescriptor:
 
         if not self.__pattern is None:
             return None
@@ -302,22 +291,11 @@ class PatternDetailsScreen(Screen):
             row_key, col_key = self.subtitleStreamsTable.coordinate_to_cell_key(self.subtitleStreamsTable.cursor_coordinate)
 
             if row_key is not None:
-                selected_track_data = self.subtitleStreamsTable.get_row(row_key)
 
+                selected_track_data = self.subtitleStreamsTable.get_row(row_key)
                 subIndex = int(selected_track_data[0])
 
-                subtitleTrack = self.__tc.findTrack(self.__pattern.getId(), TrackType.SUBTITLE, subIndex)
+                return self.__tc.findTrack(self.__pattern.getId(), TrackType.SUBTITLE, subIndex).getDescriptor()
-
-                kwargs = {}
-
-                kwargs[TrackDescriptor.PATTERN_ID_KEY] = self.__pattern.getId()
-                kwargs[TrackDescriptor.SUB_INDEX_KEY] = subIndex
-
-                kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
-                kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleTrack.getDispositionSet()
-                kwargs[TrackDescriptor.TAGS_KEY] = subtitleTrack.getTags()
-
-                return TrackDescriptor(**kwargs)
 
             else:
                 return None

bin/ffx/tag_controller.py

@@ -19,175 +19,225 @@ class TagController():
         self.Session = self.context['database']['session'] # convenience
 
 
-    def addMediaTag(self, trackDescriptor):
+    def updateMediaTag(self, trackId, tagKey, tagValue):
 
         try:
             s = self.Session()
 
-            track = Track(pattern_id = int(trackDescriptor['pattern_id']),
+            q = s.query(MediaTag).filter(MediaTag.track_id == int(trackId),
-
+                                MediaTag.key == str(tagKey),
-                            track_type = int(trackDescriptor['type'].value),
+                                MediaTag.value == str(tagValue))
-
+            tag = q.first()
-                            sub_index = int(trackDescriptor['sub_index']),
+            if tag:
-
+                tag.value = str(tagValue)
-                            # language = str(trackDescriptor['language'].threeLetter()),
+            else:
-                            # title = str(trackDescriptor['title']),
+                tag = MediaTag(track_id = int(trackId),
-
+                                key = str(tagKey),
-                            disposition_flags = int(TrackDisposition.toFlags(trackDescriptor['disposition_list'])))
+                                value = str(tagValue))
-
+                s.add(tag)
-            s.add(track)
             s.commit()
 
+            return int(tag.id)
+
         except Exception as ex:
-            raise click.ClickException(f"TrackController.addTrack(): {repr(ex)}")
+            raise click.ClickException(f"TagController.updateTrackTag(): {repr(ex)}")
         finally:
             s.close()
 
-    def addTrackTag(self, trackDescriptor):
+    def updateTrackTag(self, trackId, tagKey, tagValue):
 
         try:
             s = self.Session()
 
-            track = Track(pattern_id = int(trackDescriptor['pattern_id']),
+            q = s.query(TrackTag).filter(TrackTag.track_id == int(trackId),
-
+                                TrackTag.key == str(tagKey),
-                            track_type = int(trackDescriptor['type'].value),
+                                TrackTag.value == str(tagValue))
-
+            tag = q.first()
-                            sub_index = int(trackDescriptor['sub_index']),
+            if tag:
-
+                tag.value = str(tagValue)
-                            # language = str(trackDescriptor['language'].threeLetter()),
+            else:
-                            # title = str(trackDescriptor['title']),
+                tag = TrackTag(track_id = int(trackId),
-
+                                key = str(tagKey),
-                            disposition_flags = int(TrackDisposition.toFlags(trackDescriptor['disposition_list'])))
+                                value = str(tagValue))
-
+                s.add(tag)
-            s.add(track)
             s.commit()
 
+            return int(tag.id)
+
         except Exception as ex:
-            raise click.ClickException(f"TrackController.addTrack(): {repr(ex)}")
+            raise click.ClickException(f"TagController.updateTrackTag(): {repr(ex)}")
         finally:
             s.close()
 
 
-
+#     def addTrackTag(self, trackDescriptor):
-    def updateTrack(self, trackId, trackDescriptor):
+# 
+#         try:
+#             s = self.Session()
+# 
+#             track = Track(pattern_id = int(trackDescriptor['pattern_id']),
+# 
+#                             track_type = int(trackDescriptor['type'].value),
+# 
+#                             sub_index = int(trackDescriptor['sub_index']),
+# 
+#                             # language = str(trackDescriptor['language'].threeLetter()),
+#                             # title = str(trackDescriptor['title']),
+# 
+#                             disposition_flags = int(TrackDisposition.toFlags(trackDescriptor['disposition_list'])))
+# 
+#             s.add(track)
+#             s.commit()
+# 
+#         except Exception as ex:
+#             raise click.ClickException(f"TrackController.addTrack(): {repr(ex)}")
+#         finally:
+#             s.close()
+# 
+# 
+# 
+#     def updateTrack(self, trackId, trackDescriptor):
+# 
+#         try:
+#             s = self.Session()
+#             q = s.query(Track).filter(Track.id == int(trackId))
+# 
+#             if q.count():
+# 
+#                 track = q.first()
+# 
+#                 track.sub_index = int(trackDescriptor['sub_index'])
+#                 # track.language = str(trackDescriptor['language'].threeLetter())
+#                 # track.title = str(trackDescriptor['title'])
+#                 track.disposition_flags = int(TrackDisposition.toFlags(trackDescriptor['disposition_list']))
+# 
+#                 s.commit()
+# 
+#                 return True
+# 
+#             else:
+#                 return False
+# 
+#         except Exception as ex:
+#             raise click.ClickException(f"TrackController.addTrack(): {repr(ex)}")
+#         finally:
+#             s.close()
+    def findAllMediaTags(self, trackId) -> dict:
 
         try:
             s = self.Session()
-            q = s.query(Track).filter(Track.id == int(trackId))
+                
+            q = s.query(MediaTag).filter(MediaTag.track_id == int(trackId))
 
             if q.count():
-
+                return {t.key:t.value for t in q.all()}
-                track = q.first()
-
-                track.sub_index = int(trackDescriptor['sub_index'])
-                # track.language = str(trackDescriptor['language'].threeLetter())
-                # track.title = str(trackDescriptor['title'])
-                track.disposition_flags = int(TrackDisposition.toFlags(trackDescriptor['disposition_list']))
-
-                s.commit()
-
-                return True
-
             else:
-                return False
+                return {}
 
         except Exception as ex:
-            raise click.ClickException(f"TrackController.addTrack(): {repr(ex)}")
+            raise click.ClickException(f"TagController.findAllMediaTags(): {repr(ex)}")
         finally:
             s.close()
 
 
-    def findAllTracks(self, patternId):
+    def findAllTrackTags(self, trackId) -> dict:
 
         try:
             s = self.Session()
-
-            trackDescriptors = {}
-            trackDescriptors[TrackType.AUDIO.label()] = []
-            trackDescriptors[TrackType.SUBTITLE.label()] = []
-
-            q_audio = s.query(Track).filter(Track.pattern_id == int(patternId), Track.track_type == TrackType.AUDIO.index())
-            for audioTrack in q_audio.all():
-                trackDescriptors[TrackType.AUDIO.label()].append(audioTrack.id)
                 
-            q_subtitle = s.query(Track).filter(Track.pattern_id == int(patternId), Track.track_type == TrackType.SUBTITLE.index())
+            q = s.query(TrackTag).filter(TrackTag.track_id == int(trackId))
-            for subtitleTrack in q_subtitle.all():
-                trackDescriptors[TrackType.SUBTITLE.label()].append(subtitleTrack.id)
 
-            return trackDescriptors
+            if q.count():
+                return {t.key:t.value for t in q.all()}
+            else:
+                return {}
 
         except Exception as ex:
-            raise click.ClickException(f"TrackController.findAllTracks(): {repr(ex)}")
+            raise click.ClickException(f"TagController.findAllTracks(): {repr(ex)}")
         finally:
             s.close()
 
 
-    def findTrack(self, patternId, trackType : TrackType, subIndex):
+    def findMediaTag(self, trackId : int, trackKey : str) -> MediaTag:
         
         try:
             s = self.Session()
-            q = s.query(Track).filter(Track.pattern_id == int(patternId), Track.track_type == trackType.value, Track.sub_index == int(subIndex))
+            q = s.query(Track).filter(MediaTag.track_id == int(trackId), MediaTag.key == str(trackKey))
 
             if q.count():
-                track = q.first()
+                return q.first()
-                return int(track.id)
             else:
                 return None
 
         except Exception as ex:
-            raise click.ClickException(f"TrackController.findTrack(): {repr(ex)}")
+            raise click.ClickException(f"TagController.findMediaTag(): {repr(ex)}")
         finally:
             s.close()
 
-
+    def findTrackTag(self, trackId : int, tagKey : str) -> TrackTag:
-    def getTrackDescriptor(self, trackId):
+        
-
         try:
             s = self.Session()
-            q = s.query(Track).filter(Track.id == int(trackId))
+            q = s.query(TrackTag).filter(TrackTag.track_id == int(trackId), TrackTag.key == str(tagKey))
 
             if q.count():
-                track = q.first()
+                return q.first()
-                #return self.getTrackDict(track)
-                return track.getDescriptor()
             else:
-                return {}
+                return None
 
         except Exception as ex:
-            raise click.ClickException(f"TrackController.getTrackDescriptor(): {repr(ex)}")
+            raise click.ClickException(f"TagController.findTrackTag(): {repr(ex)}")
         finally:
             s.close()
 
 
-    def deleteTrack(self, trackId):
+
+    def deleteMediaTag(self, tagId) -> bool:
         try:
             s = self.Session()
-            q = s.query(Track).filter(Track.id == int(trackId))
+            q = s.query(MediaTag).filter(MediaTag.id == int(tagId))
 
             if q.count():
 
-                trackDescriptor = self.getTrackDict(q.first())
+                tag = q.first()
 
+                s.delete(tag)
 
-                q_siblings = s.query(Track).filter(Track.pattern_id == int(trackDescriptor['pattern_id']), Track.track_type == trackDescriptor['type'].value).order_by(Track.sub_index)
+                s.commit()
+                return True
 
-                subIndex = 0
+            return False
-                for track in q_siblings.all():
 
-                    if track.sub_index == trackDescriptor['sub_index']:
+        except Exception as ex:
-                        s.delete(track)
+            raise click.ClickException(f"TagController.deleteMediaTag(): {repr(ex)}")
-                    else:
+        finally:
-                        track.sub_index = subIndex
+            s.close()
-                        subIndex += 1
+
+
+    def deleteTrackTag(self, tagId : int) -> bool:
+
+        if type(tagId) is not int:
+            raise TypeError('TagController.deleteTrackTag(): Argument tagId is required to be of type int')
+
+        try:
+            s = self.Session()
+            q = s.query(TrackTag).filter(TrackTag.id == int(tagId))
+
+            # raise click.ClickException(f"tagId={tagId}")
+            # raise click.ClickException(f"q count={q.count()}")
+
+            if q.count():
+
+                tag = q.first()
+
+                s.delete(tag)
 
                 s.commit()
                 return True
 
-
             return False
 
-
         except Exception as ex:
-            raise click.ClickException(f"TrackController.deleteTrack(): {repr(ex)}")
+            raise click.ClickException(f"TagController.deleteTrackTag(): {repr(ex)}")
         finally:
             s.close()

bin/ffx/tag_delete_screen.py

@@ -16,7 +16,7 @@ from .track_controller import TrackController
 from .track_type import TrackType
 
 # Screen[dict[int, str, int]]
-class TrackDeleteScreen(Screen):
+class TagDeleteScreen(Screen):
 
     CSS = """
 
@@ -48,6 +48,9 @@ class TrackDeleteScreen(Screen):
     .four {
         column-span: 4;
     }
+    .five {
+        column-span: 5;
+    }
 
     .box {
         height: 100%;
@@ -55,26 +58,16 @@ class TrackDeleteScreen(Screen):
     }
     """
 
-    def __init__(self, trackDescriptor : TrackDescriptor):
+    def __init__(self, key=None, value=None):
         super().__init__()
-
+        self.__key = key
-        self.context = self.app.getContext()
+        self.__value = value
-        self.Session = self.context['database']['session'] # convenience
-
-        if type(trackDescriptor) is not TrackDescriptor:
-            raise click.ClickException('TrackDeleteScreen.init(): trackDescriptor is required to be of type TrackDescriptor')
-
-        self.__tc = TrackController(context = self.context)
-
-        self.__trackDescriptor = trackDescriptor
 
 
     def on_mount(self):
 
-        self.query_one("#subindexlabel", Static).update(str(self.__trackDescriptor.getSubIndex()))
+        self.query_one("#keylabel", Static).update(str(self.__key))
-        self.query_one("#patternlabel", Static).update(str(self.__trackDescriptor.getPatternId()))
+        self.query_one("#valuelabel", Static).update(str(self.__value))
-        self.query_one("#languagelabel", Static).update(str(self.__trackDescriptor.getLanguage().label()))
-        self.query_one("#titlelabel", Static).update(str(str(self.__trackDescriptor.getTitle())))
 
 
     def compose(self):
@@ -84,32 +77,18 @@ class TrackDeleteScreen(Screen):
         with Grid():
             
             #1
-            yield Static(f"Are you sure to delete the following {self.__trackDescriptor.getType().label()} track?", id="toplabel", classes="four")
+            yield Static(f"Are you sure to delete this tag ?", id="toplabel", classes="five")
 
             #2
-            yield Static("sub index")
+            yield Static("Key")
-            yield Static(" ", id="subindexlabel", classes="three")
+            yield Static(" ", id="keylabel", classes="four")
 
             #3
-            yield Static("from pattern")
+            yield Static("Value")
-            yield Static(" ", id="patternlabel", classes="three")
+            yield Static(" ", id="valuelabel", classes="four")
 
             #4
-            yield Static(" ", classes="four")
+            yield Static(" ", classes="five")
-
-            #5
-            yield Static("Language")
-            yield Static(" ", id="languagelabel", classes="three")
-
-            #6
-            yield Static("Title")
-            yield Static(" ", id="titlelabel", classes="three")
-
-            #7
-            yield Static(" ", classes="four")
-
-            #8
-            yield Static(" ", classes="four")
 
             #9
             yield Button("Delete", id="delete_button")
@@ -123,19 +102,8 @@ class TrackDeleteScreen(Screen):
 
         if event.button.id == "delete_button":
 
-            track = self.__tc.findTrack(self.__trackDescriptor.getPatternId(), self.__trackDescriptor.getType(), self.__trackDescriptor.getSubIndex())
+            tag = (self.__key, self.__value)                  
-
+            self.dismiss(tag)
-            if track is None:
-                raise click.ClickException(f"Track is none: patternId={self.__trackDescriptor.getPatternId()} type={self.__trackDescriptor.getType()} subIndex={self.__trackDescriptor.getSubIndex()}")
-
-            if track is not None:
-
-                if self.__tc.deleteTrack(track.getId()):                    
-                    self.dismiss(self.__trackDescriptor)
-
-                else:
-                    #TODO: Meldung
-                    self.app.pop_screen()
 
         if event.button.id == "cancel_button":
             self.app.pop_screen()

bin/ffx/tag_details_screen.py

@@ -67,7 +67,6 @@ class TagDetailsScreen(Screen):
         self.__value = value
 
 
-
     def on_mount(self):
 
         if self.__key is not None:

bin/ffx/track_controller.py

@@ -10,6 +10,7 @@ from .iso_language import IsoLanguage
 from .track_type import TrackType
 
 from ffx.model.track_tag import TrackTag
+from ffx.track_descriptor import TrackDescriptor
 
 
 class TrackController():
@@ -24,7 +25,6 @@ class TrackController():
 
         try:
             s = self.Session()
-
             track = Track(pattern_id = int(trackDescriptor.getPatternId()),
                             track_type = int(trackDescriptor.getType().index()),
                             sub_index = int(trackDescriptor.getSubIndex()),
@@ -47,7 +47,10 @@ class TrackController():
             s.close()
 
 
-    def updateTrack(self, trackId, trackDescriptor):
+    def updateTrack(self, trackId, trackDescriptor : TrackDescriptor):
+
+        if type(trackDescriptor) is not TrackDescriptor:
+            raise TypeError('TrackController.updateTrack(): Argument trackDescriptor is required to be of type TrackDescriptor')
 
         try:
             s = self.Session()
@@ -55,50 +58,37 @@ class TrackController():
 
             if q.count():
 
-                track = q.first()
+                track : Track = q.first()
 
-                track.sub_index = int(trackDescriptor['sub_index'])
+                track.sub_index = int(trackDescriptor.getSubIndex())
-                # track.language = str(trackDescriptor['language'].threeLetter())
-                # track.title = str(trackDescriptor['title'])
                 track.disposition_flags = int(TrackDisposition.toFlags(trackDescriptor.getDispositionSet()))
 
-                s.commit()
+                descriptorTagKeys = trackDescriptor.getTags()
+                tagKeysInDescriptor = set(descriptorTagKeys.keys())
+                tagKeysInDb = {t.key for t in track.track_tags}
 
+                for k in tagKeysInDescriptor & tagKeysInDb: # to update
+                    tags = [t for t in track.track_tags if t.key == k]
+                    tags[0].value = descriptorTagKeys[k]
+                for k in tagKeysInDescriptor - tagKeysInDb: # to add
+                    tag = TrackTag(track_id=track.id, key=k, value=descriptorTagKeys[k])
+                    s.add(tag)
+                for k in tagKeysInDb - tagKeysInDescriptor: # to remove
+                    tags = [t for t in track.track_tags if t.key == k]
+                    s.delete(tags[0])
+
+                s.commit()
                 return True
 
             else:
                 return False
 
         except Exception as ex:
-            raise click.ClickException(f"TrackController.addTrack(): {repr(ex)}")
+            raise click.ClickException(f"TrackController.updateTrack(): {repr(ex)}")
         finally:
             s.close()
 
-#
+
-#    def findAllTracks(self, patternId):
-#
-#        try:
-#            s = self.Session()
-#
-#            trackDescriptors = {}
-#            trackDescriptors[TrackType.AUDIO.label()] = []
-#            trackDescriptors[TrackType.SUBTITLE.label()] = []
-#
-#            q_audio = s.query(Track).filter(Track.pattern_id == int(patternId), Track.track_type == TrackType.AUDIO.index())
-#            for audioTrack in q_audio.all():
-#                trackDescriptors[TrackType.AUDIO.label()].append(audioTrack.id)
-#                
-#            q_subtitle = s.query(Track).filter(Track.pattern_id == int(patternId), Track.track_type == TrackType.SUBTITLE.index())
-#            for subtitleTrack in q_subtitle.all():
-#                trackDescriptors[TrackType.SUBTITLE.label()].append(subtitleTrack.id)
-#
-#            return trackDescriptors
-#
-#        except Exception as ex:
-#            raise click.ClickException(f"TrackController.findAllTracks(): {repr(ex)}")
-#        finally:
-#            s.close()
-#
     def findAudioTracks(self, patternId):
 
         try:
@@ -126,7 +116,7 @@ class TrackController():
             s.close()
 
 
-    def findTrack(self, patternId : int, trackType : TrackType, subIndex : int):
+    def findTrack(self, patternId : int, trackType : TrackType, subIndex : int) -> Track:
         
         try:
             s = self.Session()

bin/ffx/track_descriptor.py

@@ -6,6 +6,7 @@ from .track_disposition import TrackDisposition
 
 class TrackDescriptor():
     
+        ID_KEY = 'id'
         INDEX_KEY = 'index'
         SUB_INDEX_KEY = 'sub_index'
         PATTERN_ID_KEY = 'pattern_id'
@@ -20,6 +21,13 @@ class TrackDescriptor():
 
         def __init__(self, **kwargs):
 
+                if TrackDescriptor.ID_KEY in kwargs.keys():
+                        if type(kwargs[TrackDescriptor.ID_KEY]) is not int:
+                                raise TypeError(f"TrackDesciptor.__init__(): Argument {TrackDescriptor.ID_KEY} is required to be of type int")
+                        self.__trackId = kwargs[TrackDescriptor.ID_KEY]
+                else:
+                        self.__trackId = -1
+
                 if TrackDescriptor.PATTERN_ID_KEY in kwargs.keys():
                         if type(kwargs[TrackDescriptor.PATTERN_ID_KEY]) is not int:
                                 raise TypeError(f"TrackDesciptor.__init__(): Argument {TrackDescriptor.PATTERN_ID_KEY} is required to be of type int")
@@ -134,6 +142,9 @@ class TrackDescriptor():
                         return None
 
 
+        def getId(self):
+                return self.__trackId
+
         def getPatternId(self):
                 return self.__patternId
 

bin/ffx/track_details_screen.py

@@ -12,6 +12,7 @@ from ffx.model.pattern import Pattern
 
 from .track_controller import TrackController
 from .pattern_controller import PatternController
+from .tag_controller import TagController
 # from .show_controller import ShowController
 
 from .track_type import TrackType
@@ -23,76 +24,11 @@ from .audio_layout import AudioLayout
 from .track_descriptor import TrackDescriptor
 
 from .tag_details_screen import TagDetailsScreen
+from .tag_delete_screen import TagDeleteScreen
 
 from textual.widgets._data_table import CellDoesNotExist
 
 
-class EditableDataTable(DataTable):
-    """Custom DataTable that allows editing cells upon mouse click."""
-
-    def on_click(self, event: events.Click) -> None:
-        """Handle mouse clicks on the table."""
-
-        # raise click.ClickException(f"event={event}")
-    
-        #event.x und event.y sind koordinaten im Datatable
-
-        #clicked_cell = self.coordinate_to_cell_key(self.cursor_coordinate)
-        #raise click.ClickException(f"x={event.x} y={event.y} clicked_cell={clicked_cell}")
-
-
-        #raise click.ClickException(f"cuco={self.cursor_coordinate}")
-
-        #clickCoordinates = Coordinate(row = event.y, column=event.x)
-
-        #clicked_cell = self.get_cell_at(event.x, event.y)
-        #row_key, col_key = self.coordinate_to_cell_key(self.cursor_coordinate)
-
-        #raise click.ClickException(f"x={event.x} y={event.y} row={row_key} col={col_key}")
-
-
-        #if clicked_cell:
-        # if row_key is not None and col_key is not None:
-            #row, column = clicked_cell
-            # Get the current cell value and activate editing.
-            #current_value = self.get_cell(row_key, col_key)
-        current_value = self.get_cell_at(self.cursor_coordinate)
-
-        region = self._get_cell_region(self.cursor_coordinate)
-
-        raise click.ClickException(f"region={region}")
-
-        #current_value = self.get_cell(row_key, col_key)
-            #self.activate_cell_edit(row_key, col_key, current_value)
-
-        raise click.ClickException(f"val={current_value}")
-
-    def activate_cell_edit(self, row: int, column: int, value: str) -> None:
-#         """Method to activate cell editing."""
-#         # Create a new input box with the value of the cell to be edited.
-        input_box = Input(value=value, classes="cell-editor")
-        input_box.styles.width = len(value) + 2  # Adjust the width of the input box
-        input_box.styles.padding = (0, 1)
-# 
-#         # Position the input box over the cell to be edited.
-        input_box.styles.position = "absolute"
-        input_box.styles.left = self.get_cell_position(row, column)[0]
-        input_box.styles.top = self.get_cell_position(row, column)[1]
-
-#         # Add the input box to the parent widget for editing.
-#         self.app.mount(input_box)
-#         input_box.focus()
-# 
-#         # Listen to when the user completes editing.
-#         input_box.on_blur = lambda event: self.save_cell_value(row, column, input_box.value)
-# 
-#     def save_cell_value(self, row: int, column: int, value: str) -> None:
-#         """Save the new value to the table and remove the input box."""
-#         self.update_cell(row, column, value)
-#         self.app.query_one(".cell-editor").remove()  # Remove the input box after saving.
-
-
-
 # Screen[dict[int, str, int]]
 class TrackDetailsScreen(Screen):
 
@@ -156,18 +92,37 @@ class TrackDetailsScreen(Screen):
 
         self.__tc = TrackController(context = self.context)
         self.__pc = PatternController(context = self.context)
+        self.__tac = TagController(context = self.context)
 
         self.__isNew = trackDescriptor is None
         if self.__isNew:
             self.__trackType = trackType
             self.__subIndex = subIndex
-            self.__trackDescriptor = None
+            self.__trackDescriptor : TrackDescriptor = None
-            self.__pattern = self.__pc.getPattern(patternId) if patternId is not None else {}
+            self.__pattern : Pattern = self.__pc.getPattern(patternId) if patternId is not None else {}
         else:
             self.__trackType = trackDescriptor.getType()
             self.__subIndex = trackDescriptor.getSubIndex()
-            self.__trackDescriptor = trackDescriptor
+            self.__trackDescriptor : TrackDescriptor = trackDescriptor
-            self.__pattern = self.__pc.getPattern(self.__trackDescriptor.getPatternId())
+            self.__pattern : Pattern = self.__pc.getPattern(self.__trackDescriptor.getPatternId())
+
+
+
+    def updateTags(self):
+
+        self.trackTagsTable.clear()
+
+        trackId = self.__trackDescriptor.getId()
+
+        if trackId != -1:
+
+            trackTags = self.__tac.findAllTrackTags(trackId)
+
+            for k,v in trackTags.items():
+
+                if k != 'language' and k != 'title':
+                    row = (k,v)
+                    self.trackTagsTable.add_row(*map(str, row))
 
 
     def on_mount(self):
@@ -175,12 +130,9 @@ class TrackDetailsScreen(Screen):
         if self.__pattern is not None:
             self.query_one("#patternlabel", Static).update(self.__pattern.getPattern())
 
-
         if self.__subIndex is not None:
             self.query_one("#subindexlabel", Static).update(str(self.__subIndex))
 
-
-
         for d in TrackDisposition:
 
             dispositionIsSet = (self.__trackDescriptor is not None
@@ -193,11 +145,12 @@ class TrackDetailsScreen(Screen):
 
             self.query_one("#language_select", Select).value = self.__trackDescriptor.getLanguage().label()
             self.query_one("#title_input", Input).value = self.__trackDescriptor.getTitle()
+            self.updateTags()
 
 
     def compose(self):
 
-        self.trackTagsTable = EditableDataTable(classes="five")
+        self.trackTagsTable = DataTable(classes="five")
 
         # Define the columns with headers
         self.column_key_track_tag_key = self.trackTagsTable.add_column("Key", width=10)
@@ -297,13 +250,15 @@ class TrackDetailsScreen(Screen):
 
         trackTags = {}
         language = self.query_one("#language_select", Select).value
-        # raise click.ClickException(f"language={language}")
         if language:
             trackTags['language'] = IsoLanguage.find(language).threeLetter()
         title = self.query_one("#title_input", Input).value
         if title:
             trackTags['title'] = title
-        kwargs[TrackDescriptor.TAGS_KEY] = trackTags
+
+        tableTags = {row[0]:row[1] for r in self.trackTagsTable.rows if (row := self.trackTagsTable.get_row(r)) and row[0] != 'language' and row[0] != 'title'}
+
+        kwargs[TrackDescriptor.TAGS_KEY] = trackTags | tableTags
 
         dispositionFlags = sum([2**f for f in self.query_one("#dispositions_selection_list", SelectionList).selected])
         kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = TrackDisposition.toSet(dispositionFlags)
@@ -346,6 +301,8 @@ class TrackDetailsScreen(Screen):
 
             trackDescriptor = self.getTrackDescriptorFromInput()
 
+            # raise click.ClickException(f"td.tags={trackDescriptor.getTags()}") # language=ger, title=Deutsch
+
             # Check for multiple default/forced disposition flags
 
             if self.__trackType == TrackType.AUDIO:
@@ -376,9 +333,9 @@ class TrackDetailsScreen(Screen):
 
                 else:
 
-                    trackId = self.__tc.findTrack(self.__pattern.getId(), self.__trackType, self.__subIndex)
+                    track = self.__tc.findTrack(self.__pattern.getId(), self.__trackType, self.__subIndex)
 
-                    if self.__tc.updateTrack(trackId, trackDescriptor):
+                    if self.__tc.updateTrack(track.getId(), trackDescriptor):
                         self.dismiss(trackDescriptor)
 
                     else:
@@ -401,17 +358,23 @@ class TrackDetailsScreen(Screen):
             self.app.push_screen(TagDetailsScreen(key=tagKey, value=tagValue), self.handle_add_tag)
 
         if event.button.id == "button_delete_stream_tag":
-            pass
+            tagKey, tagValue = self.getSelectedTag()
+            self.app.push_screen(TagDeleteScreen(key=tagKey, value=tagValue), self.handle_delete_tag)
 
 
 
     def handle_add_tag(self, tag):
 
-        row = (tag[0], tag[1])
+        trackId = self.__trackDescriptor.getId()
-        self.trackTagsTable.add_row(*map(str, row))
+
+        if trackId == -1:
+            raise click.ClickException(f"TrackDetailsScreen.handle_add_tag: trackId not set (-1) trackDescriptor={self.__trackDescriptor}")
 
+        if self.__tac.updateTrackTag(trackId, tag[0], tag[1]) is not None:
+            self.updateTags()
 
-    def handle_edit_tag(self, trackDescriptor : TrackDescriptor):
+
+    def handle_edit_tag(self, tag):
         pass
 #         try:
 #             if trackDescriptor.getType() == TrackType.AUDIO:
@@ -436,15 +399,16 @@ class TrackDetailsScreen(Screen):
 #             pass
 
 
-    def handle_delete_tag(self, trackDescriptor : TrackDescriptor):
+    def handle_delete_tag(self, trackTag):
-        pass
+
-#         try:
+        trackId = self.__trackDescriptor.getId()
-#             if trackDescriptor.getType() == TrackType.AUDIO:
+
-#                 self.updateAudioTracks()
+        if trackId == -1:
-# 
+            raise click.ClickException(f"TrackDetailsScreen.handle_delete_tag: trackId not set (-1) trackDescriptor={self.__trackDescriptor}")
-#             if trackDescriptor.getType() == TrackType.SUBTITLE:
+
-#                 self.updateSubtitleTracks()
+        tag = self.__tac.findTrackTag(trackId, trackTag[0])
-# 
-#         except CellDoesNotExist:
-#             pass
 
+        if tag is not None:
+            if self.__tac.deleteTrackTag(tag.id):
+                # raise click.ClickException('deleted!')
+                self.updateTags()