From 131cca2c53acf1c819d564b5596a08468b375ae5 Mon Sep 17 00:00:00 2001 From: Maveno Date: Sun, 6 Oct 2024 16:07:23 +0200 Subject: [PATCH] tracktags UI mwe --- bin/ffx/model/track.py | 22 ++- bin/ffx/pattern_details_screen.py | 32 +---- bin/ffx/tag_controller.py | 224 ++++++++++++++++++------------ bin/ffx/tag_delete_screen.py | 66 +++------ bin/ffx/tag_details_screen.py | 1 - bin/ffx/track_controller.py | 58 ++++---- bin/ffx/track_descriptor.py | 11 ++ bin/ffx/track_details_screen.py | 150 ++++++++------------ 8 files changed, 272 insertions(+), 292 deletions(-) diff --git a/bin/ffx/model/track.py b/bin/ffx/model/track.py index 4b25c47..49d405b 100644 --- a/bin/ffx/model/track.py +++ b/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) diff --git a/bin/ffx/pattern_details_screen.py b/bin/ffx/pattern_details_screen.py index 92f26fb..827e399 100644 --- a/bin/ffx/pattern_details_screen.py +++ b/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) - - 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) + return self.__tc.findTrack(self.__pattern.getId(), TrackType.AUDIO, subIndex).getDescriptor() 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) - - 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) + return self.__tc.findTrack(self.__pattern.getId(), TrackType.SUBTITLE, subIndex).getDescriptor() else: return None diff --git a/bin/ffx/tag_controller.py b/bin/ffx/tag_controller.py index 527476e..9db9d01 100644 --- a/bin/ffx/tag_controller.py +++ b/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']), - - 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) + q = s.query(MediaTag).filter(MediaTag.track_id == int(trackId), + MediaTag.key == str(tagKey), + MediaTag.value == str(tagValue)) + tag = q.first() + if tag: + tag.value = str(tagValue) + else: + tag = MediaTag(track_id = int(trackId), + key = str(tagKey), + value = str(tagValue)) + s.add(tag) 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']), - - 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) + q = s.query(TrackTag).filter(TrackTag.track_id == int(trackId), + TrackTag.key == str(tagKey), + TrackTag.value == str(tagValue)) + tag = q.first() + if tag: + tag.value = str(tagValue) + else: + tag = TrackTag(track_id = int(trackId), + key = str(tagKey), + value = str(tagValue)) + s.add(tag) 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 updateTrack(self, trackId, trackDescriptor): +# def addTrackTag(self, 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(): - - 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 - + return {t.key:t.value for t in q.all()} 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()) - for subtitleTrack in q_subtitle.all(): - trackDescriptors[TrackType.SUBTITLE.label()].append(subtitleTrack.id) + q = s.query(TrackTag).filter(TrackTag.track_id == int(trackId)) - 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 int(track.id) + return q.first() 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 getTrackDescriptor(self, trackId): - + def findTrackTag(self, trackId : int, tagKey : str) -> TrackTag: + 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 self.getTrackDict(track) - return track.getDescriptor() + return q.first() 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 - for track in q_siblings.all(): + return False - if track.sub_index == trackDescriptor['sub_index']: - s.delete(track) - else: - track.sub_index = subIndex - subIndex += 1 + except Exception as ex: + raise click.ClickException(f"TagController.deleteMediaTag(): {repr(ex)}") + finally: + s.close() + + + 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() diff --git a/bin/ffx/tag_delete_screen.py b/bin/ffx/tag_delete_screen.py index da68e78..aaf536a 100644 --- a/bin/ffx/tag_delete_screen.py +++ b/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.context = self.app.getContext() - 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 + self.__key = key + self.__value = value def on_mount(self): - self.query_one("#subindexlabel", Static).update(str(self.__trackDescriptor.getSubIndex())) - self.query_one("#patternlabel", Static).update(str(self.__trackDescriptor.getPatternId())) - self.query_one("#languagelabel", Static).update(str(self.__trackDescriptor.getLanguage().label())) - self.query_one("#titlelabel", Static).update(str(str(self.__trackDescriptor.getTitle()))) + self.query_one("#keylabel", Static).update(str(self.__key)) + self.query_one("#valuelabel", Static).update(str(self.__value)) 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(" ", id="subindexlabel", classes="three") + yield Static("Key") + yield Static(" ", id="keylabel", classes="four") #3 - yield Static("from pattern") - yield Static(" ", id="patternlabel", classes="three") + yield Static("Value") + yield Static(" ", id="valuelabel", classes="four") #4 - yield Static(" ", classes="four") - - #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") + yield Static(" ", classes="five") #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()) - - 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() + tag = (self.__key, self.__value) + self.dismiss(tag) if event.button.id == "cancel_button": self.app.pop_screen() diff --git a/bin/ffx/tag_details_screen.py b/bin/ffx/tag_details_screen.py index c85500f..46b29d2 100644 --- a/bin/ffx/tag_details_screen.py +++ b/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: diff --git a/bin/ffx/track_controller.py b/bin/ffx/track_controller.py index eb59db9..fc27f57 100644 --- a/bin/ffx/track_controller.py +++ b/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.language = str(trackDescriptor['language'].threeLetter()) - # track.title = str(trackDescriptor['title']) + track.sub_index = int(trackDescriptor.getSubIndex()) 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() diff --git a/bin/ffx/track_descriptor.py b/bin/ffx/track_descriptor.py index 0962939..e9d1273 100644 --- a/bin/ffx/track_descriptor.py +++ b/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 diff --git a/bin/ffx/track_details_screen.py b/bin/ffx/track_details_screen.py index b7c4622..492e68f 100644 --- a/bin/ffx/track_details_screen.py +++ b/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.__pattern = self.__pc.getPattern(patternId) if patternId is not None else {} + self.__trackDescriptor : TrackDescriptor = None + 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.__pattern = self.__pc.getPattern(self.__trackDescriptor.getPatternId()) + self.__trackDescriptor : TrackDescriptor = trackDescriptor + 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]) - self.trackTagsTable.add_row(*map(str, row)) + trackId = self.__trackDescriptor.getId() + + 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): - pass -# try: -# if trackDescriptor.getType() == TrackType.AUDIO: -# self.updateAudioTracks() -# -# if trackDescriptor.getType() == TrackType.SUBTITLE: -# self.updateSubtitleTracks() -# -# except CellDoesNotExist: -# pass + def handle_delete_tag(self, trackTag): + + trackId = self.__trackDescriptor.getId() + + if trackId == -1: + raise click.ClickException(f"TrackDetailsScreen.handle_delete_tag: trackId not set (-1) trackDescriptor={self.__trackDescriptor}") + + tag = self.__tac.findTrackTag(trackId, trackTag[0]) + if tag is not None: + if self.__tac.deleteTrackTag(tag.id): + # raise click.ClickException('deleted!') + self.updateTags()