def get_selection_from_view(widget: Gtk.TreeView) -> list: _, selections = (widget.get_selection()).get_selected_rows() model = widget.get_model() return [ model.get_value(model.get_iter(selection), 1) for selection in selections ]
def toggle_tree_view_listening(tree_view: Gtk.TreeView, handler_id: int, func: Callable) -> Optional[int]: if handler_id is not None: # The handler exists, stop listening tree_view.disconnect(handler_id) return None else: # The handler doesn't exist, start listening return tree_view.connect('cursor-changed', func)
def on_queue_tree_view_key_pressed(self, tree_view: Gtk.TreeView, event: Gdk.EventKey) -> None: keyname = Gdk.keyval_name(event.keyval) render_task_index = tree_view.get_selection() \ .get_selected_rows()[1][0][0] current_render_task_index = self.render_queue.index( self.current_render_task) if keyname == "Delete" \ and render_task_index != current_render_task_index: del self.render_queue[render_task_index] model, iter = tree_view.get_selection().get_selected() model.remove(iter)
def get_selected_item_path(self, tree_view: Gtk.TreeView, tree_model: Gtk.TreeModel): (selected_item_path, _) = tree_view.get_cursor() if selected_item_path is not None: selected_item_iter = tree_model.get_iter(selected_item_path) else: tree_selection = tree_view.get_selection( ) # type: Gtk.TreeSelection (_, selected_item_iter) = tree_selection.get_selected( ) # type: Gtk.TreeModel, Gtk.TreeIter selected_item_path = tree_model.get_path(selected_item_iter) return selected_item_iter, selected_item_path
def __init__(self, tw: Gtk.TreeView, path: Gtk.TreePath, columns: Iterable[int]) -> None: super().__init__(1.0) self.tw = tw self.frozen = False self.sig = tw.connect_after("draw", self.on_draw) self.row = Gtk.TreeRowReference.new(tw.props.model, path) self.selection = tw.get_selection() self.columns: List[Gtk.TreeViewColumn] = [] for i in columns: self.columns.append(self.tw.get_column(i))
def append_toggle_column(self, tree_view: Gtk.TreeView, title: str, data_func: Callable[[Gtk.CellRenderer, T], None], on_changed: Optional[Callable[[T, bool], bool]] = None): renderer = Gtk.CellRendererToggle() if on_changed: renderer.connect('toggled', self._make_toggled_signal_handler(on_changed)) col = Gtk.TreeViewColumn(title, renderer) col.set_cell_data_func(renderer, self._make_data_func(data_func)) tree_view.append_column(col)
def on_transmview_keypress(self, treeview: Gtk.TreeView, event: Gdk.EventKey): if event.get_keyval()[1] in [Gdk.KEY_Delete, Gdk.KEY_KP_Delete, Gdk.KEY_BackSpace]: model, selectediter = treeview.get_selection().get_selected() if (selectediter is not None) and (model[selectediter] != ''): model.remove(selectediter) self.tidy_transmmodel(treeview) return False
def _setSubtitleTreeView(self) -> None: """ Sets the scrolled window and a tree view for subtitles info. :return: """ self._subtitles_treeview = TreeView() self._subtitles_treeview.set_grid_lines(TreeViewGridLines.BOTH) scrl_wnd: ScrolledWindow = ScrolledWindow() scrl_wnd.set_hexpand(True) scrl_wnd.set_vexpand(True) scrl_wnd.add(self._subtitles_treeview) self._subtitles_grid.attach(scrl_wnd, 0, 1, 1, 1)
def on_entry_edited(self, treeview: Gtk.TreeView, path: Gtk.TreePath, new_text: str): model = treeview.get_model() assert isinstance(model, Gtk.ListStore) try: value = float(new_text) except ValueError: return model[path][0] = '{:.2f}'.format(value) self.sort_and_tidy_model(treeview)
def sort_and_tidy_model(self, treeview: Gtk.TreeView): model, selectediter = treeview.get_selection().get_selected() assert isinstance(model, Gtk.ListStore) if selectediter is not None: prev_selected = model[selectediter][0] else: prev_selected = None values = [r[0] for r in model if r[0]] model.clear() selectediter = None for v in sorted(values, key=float): it = model.append([v]) if v == prev_selected: selectediter = it model.append(['']) if selectediter is not None: treeview.get_selection().select_iter(selectediter) return False
def on_tree_grouped_drag_data_get(self, w: Gtk.TreeView, context, selection: Gtk.SelectionData, target_id, etime): model, treeiter = w.get_selection().get_selected() dungeon_id = model[treeiter][1] was_group = model[treeiter][0] if not was_group: selection.set(selection.get_target(), 8, bytes(dungeon_id, 'utf-8'))
def on_main_item_list_button_press_event(self, tree: Gtk.TreeView, event: Gdk.Event): """Handle click on item: Switch view""" assert current_thread() == main_thread if event.type == Gdk.EventType.DOUBLE_BUTTON_PRESS: model, treeiter = tree.get_selection().get_selected() if model is not None and treeiter is not None and RomProject.get_current( ) is not None: self.load_view(model, treeiter, tree, False)
class ReaderWindow(ApplicationWindow): __gtype_name__ = 'ReaderWindow' def __init__(self, **kwargs): super(ReaderWindow, self).__init__( title='Eearth Reader', **kwargs ) app = self.get_application() assert isinstance(app, EarthReaderApp) self.set_wmclass('Earth Reader', 'Earth Reader') self.set_icon_list(ICON_LIST) self.box = Box(spacing=0) self.add(self.box) subscriptions = SubscriptionTreeModel(app.stage) self.subscriptions_sidebar = ScrolledWindow() self.subscription_list = TreeView(subscriptions) cell_renderer = CellRendererText() subscription_column = TreeViewColumn('Title', cell_renderer, text=0) def cell_data_func(column, renderer, model, tree_iter, *args): if isinstance(model[tree_iter], Category): renderer.set_property('cell-background', 'silver') else: renderer.set_property('cell-background', None) subscription_column.set_cell_data_func(cell_renderer, cell_data_func) self.subscription_list.append_column(subscription_column) self.subscriptions_sidebar.add(self.subscription_list) self.box.pack_start(self.subscriptions_sidebar, expand=True, fill=True, padding=0) entries_store = dummy_entries() entry_column = TreeViewColumn('Title', CellRendererText(), text=0) self.entry_list_box = ScrolledWindow() self.entry_list = TreeView(entries_store) self.entry_list.append_column(entry_column) self.entry_list_box.add(self.entry_list) self.box.pack_start(self.entry_list_box, expand=True, fill=True, padding=0) self.content_view = WebView() self.box.pack_start(self.content_view, expand=True, fill=True, padding=0)
def append_text_column(self, tree_view: Gtk.TreeView, title: str, data_func: Callable[[Gtk.CellRenderer, T], None], parse_func: Optional[Callable[[str], Any]] = None, on_changed: Optional[Callable[[T, Any], bool]] = None): renderer = Gtk.CellRendererText() editable = parse_func is not None and on_changed is not None if editable: renderer.props.editable = True renderer.connect( 'edited', self._make_edited_signal_handler(parse_func, on_changed)) col = Gtk.TreeViewColumn(title, renderer) col.set_cell_data_func(renderer, self._make_data_func(data_func)) tree_view.append_column(col)
def on_contents_activated(self, trvw: Gtk.TreeView, path: Gtk.TreePath, col: Gtk.TreeViewColumn) -> bool: model = trvw.get_model() entity = model[model.get_iter(path)][ModelColsContents.Entity] if entity: self.do_entity_select(entity) else: self.do_toggle_expand_row(path)
def on_blend_cell_clicked(self, tree_view: Gtk.TreeView, event: Gdk.EventButton) -> None: if event.button == Gdk.BUTTON_PRIMARY \ and event.type == Gdk.EventType._2BUTTON_PRESS: selection = tree_view.get_selection() model, tree_iter = selection.get_selected() path = model[tree_iter][0] self.blend_file_chooser_button.set_filename(path) self.update_render_settings(path) self.stack.set_visible_child_name("render_settings")
def tidy_transmmodel(self, treeview: Gtk.TreeView): model, selected_iter = treeview.get_selection().get_selected() assert isinstance(model, Gtk.ListStore) if selected_iter: selected_name = model[selected_iter][0] else: selected_name = None selected_iter = None rows = [list(r) for r in model] model.clear() for r in rows: if not r[0]: continue it = model.append(r) if r[0] == selected_name: selected_iter = it it = model.append(['', '--', '--', '--', '--', '--', '--', False, 0, -1]) if selected_iter is None: selected_iter = it treeview.get_selection().select_iter(selected_iter)
def _do_button_press_te(self, w: Gtk.TreeView, e): if e.type == Gdk.EventType.DOUBLE_BUTTON_PRESS: path = w.get_path_at_pos(e.x, e.y) if path is None: return p, c, *_ = path i = self.tagged_entries_list_store.get_iter(p) v = self.tagged_entries_list_store.get_value(i, 2) if v != "": webbrowser.open(v)
def load_view(self, model: Gtk.TreeModel, treeiter: Gtk.TreeIter, tree: Gtk.TreeView, scroll_into_view=True): logger.debug('View selected. Locking and showing Loader.') path = model.get_path(treeiter) self._lock_trees() selected_node = model[treeiter] self._init_window_before_view_load(model[treeiter]) # Show loading stack page in editor stack self._editor_stack.set_visible_child(self.builder.get_object('es_loading')) # Set current view values for later check (if race conditions between fast switching) self._current_view_module = selected_node[2] self._current_view_controller_class = selected_node[3] self._current_view_item_id = selected_node[4] # Fully load the view and the controller AsyncTaskRunner.instance().run_task(load_controller( self._current_view_module, self._current_view_controller_class, self._current_view_item_id, self )) # Expand the node tree.expand_to_path(path) # Select node tree.get_selection().select_path(path) # Scroll node into view if scroll_into_view: tree.scroll_to_cell(path, None, True, 0.5, 0.5) self._last_selected_view_model = model self._last_selected_view_iter = treeiter
def __init__( self, tw: Gtk.TreeView, path: Gtk.TreePath, columns: Optional[Collection[Gtk.TreeViewColumn]] = None) -> None: super().__init__(1.0) self.tw = tw self.sig: Optional[int] = self.tw.connect_after("draw", self.on_draw) self.row = Gtk.TreeRowReference.new(tw.props.model, path) self.stylecontext = tw.get_style_context() self.columns = columns
def updateTreeWidget(self, widget : Gtk.TreeView, tree : g.core.tree.Tree, icon : GdkPixbuf.Pixbuf): def fillStore(st : Gtk.TreeStore, treeStruct, ico : GdkPixbuf.Pixbuf): def helper(storeIter, tr): p = tr.getFullPath() it = st.append(storeIter, [ico, tr.name, p]) for child in tr.children: helper(it, child) helper(None, treeStruct) store = Gtk.TreeStore(GdkPixbuf.Pixbuf, str, str) fillStore(store, tree, icon) widget.set_model(store) rendererName = Gtk.CellRendererText() rendererIcon = Gtk.CellRendererPixbuf() columnIcon = Gtk.TreeViewColumn('Icon', rendererIcon) columnIcon.add_attribute(rendererIcon, 'pixbuf', 0) columnName = Gtk.TreeViewColumn('Name', rendererName, text=1) widget.append_column(columnIcon) widget.append_column(columnName)
def on_query_confirmations_tooltip( tree_view: Gtk.TreeView, x: int, y: int, tip: bool, tooltip: Gtk.Tooltip, ) -> bool: context = tree_view.get_tooltip_context(x, y, tip) if context[0]: if context.model.iter_depth(context.iter) != 0: return False tooltip.set_text('Id:{}\nKey:{}'.format( context.model.get_value(context.iter, 1), context.model.get_value(context.iter, 2), )) return True return False
def on_tree_grouped_drag_data_received(self, w: Gtk.TreeView, context, x, y, selection: Gtk.SelectionData, info, etime): model: Gtk.TreeStore = w.get_model() dungeon_id_str = str(selection.get_data(), 'utf-8') if dungeon_id_str == '': return dungeon_id = int(dungeon_id_str) dungeon_iter = self._find_dungeon_iter(model, dungeon_id) assert dungeon_iter is not None drop_info = w.get_dest_row_at_pos(x, y) if drop_info: path, position = drop_info iter = model.get_iter(path) did_drag = True # Did we drag onto a group or a dungeon in a group? new_group_iter = self._get_group_iter(model, iter, position) old_group_iter = self._get_group_iter(model, dungeon_iter, Gtk.TreeViewDropPosition.INTO_OR_BEFORE) if not new_group_iter: # After/Before top level: # Don't do anything if position == Gtk.TreeViewDropPosition.INTO_OR_BEFORE or position == Gtk.TreeViewDropPosition.INTO_OR_AFTER: # Inside top level, dungeon: # Build new group dungeon_id_insert = model[iter][1] before_iter = model.iter_previous(iter) assert iter is not None model.remove(iter) if before_iter is None: new_iter = model.insert(None, 0, self._generate_group_row( dungeon_id_insert )) else: new_iter = model.insert_after(model.iter_parent(before_iter), before_iter, self._generate_group_row( dungeon_id_insert )) model.append(new_iter, self._generate_dungeon_row(dungeon_id_insert)) model.append(new_iter, self._generate_dungeon_row(dungeon_id)) w.expand_row(model.get_path(new_iter), False) elif old_group_iter is not None: self._reinsert(model, dungeon_id, self._generate_dungeon_row(dungeon_id)) else: did_drag = False else: if new_group_iter == iter: # Inside top level, group: # Add to end of group assert new_group_iter is not None model.append(new_group_iter, self._generate_dungeon_row(dungeon_id)) else: # After/Before in group / Inside in group: # Add it to group after/before this element if position == Gtk.TreeViewDropPosition.INTO_OR_BEFORE or position == Gtk.TreeViewDropPosition.BEFORE: assert new_group_iter is not None model.insert_before(new_group_iter, iter, self._generate_dungeon_row(dungeon_id)) else: assert new_group_iter is not None model.insert_after(new_group_iter, iter, self._generate_dungeon_row(dungeon_id)) if did_drag: assert dungeon_iter is not None # Remove the original iter. model.remove(dungeon_iter) # Check if group headers (main id) needs to be rewritten: if old_group_iter: self._rewrite_group_header_id_and_pos(model, old_group_iter) if new_group_iter and new_group_iter != old_group_iter: self._rewrite_group_header_id_and_pos(model, new_group_iter) if old_group_iter and old_group_iter != new_group_iter: # If was in group: # Remove from group # (If removing dungeons from a group, recalculate group id, name, # position and if it even still needs to exist) if model.iter_n_children(old_group_iter) < 2: # Remove group dungeon_id_that_was_in_group = model[model.iter_nth_child(old_group_iter, 0)][1] assert old_group_iter is not None model.remove(old_group_iter) self._reinsert(model, dungeon_id_that_was_in_group, self._generate_dungeon_row(dungeon_id_that_was_in_group)) # Select the newly inserted. dungeon_iter = self._find_dungeon_iter(model, dungeon_id) w.get_selection().select_iter(dungeon_iter) w.scroll_to_cell(model.get_path(dungeon_iter), None, True, 0.5, 0.5) if context.get_actions() == Gdk.DragAction.MOVE: # We remove the source data manual. context.finish(True, False, etime)
def select(tree_view: Gtk.TreeView) -> List[Gtk.TreeViewColumn]: return [ column for column in tree_view.get_columns() if fn(column) ][0]
def model(tree_view: Gtk.TreeView) -> Gtk.TreeStore: return tree_view.get_model()
def onAlbumRowActivation(self, widget : Gtk.TreeView, p1, column : Gtk.TreeViewColumn): treeSelection = widget.get_selection() model, iter0 = treeSelection.get_selected() albumPath = model.get_value(iter0, 2) photos = self.photoDb.getPhotosByPath(albumPath) self.thumbsView.set_photos(photos)
def show_new_content(self, tree_view: Gtk.TreeView) -> None: model, it = tree_view.get_selection().get_selected() if model and it: item = self.news_store.row_to_item(model[it]) TextFormat.prepare_content_display(item, self.content_view)
def get_row_being_edited(tree_view: Gtk.TreeView) -> Optional[Gtk.TreePath]: cur = tree_view.get_cursor() if cur.focus_column: col: Gtk.TreeViewColumn = cur.focus_column if any(c.props.editing for c in col.get_cells()): return cur.path
def show_new_headlines(self, tree_view: Gtk.TreeView) -> None: self.focused_index = 0 # Correctly anchors left/right keyboard shortcut if the mouse was used. model, it = tree_view.get_selection().get_selected() if model and it: self.last_item_feed_name = model[it][0] self.headline_view.do_unselect_all(self.headline_view)
def row_to_html(self, model: Gtk.ListStore, path: Gtk.TreePath, it: Gtk.TreeIter, treeview: Gtk.TreeView): self.html_being_built += " <tr>\n" for c in treeview.get_columns(): self.html_being_built += " <td>" + self.cell_data_func(c, None, model, it, None) + "</td>\n" self.html_being_built += " </tr>"
class CardsGenerator(Window): def __init__(self, parent: Window, app: Application, col_filename: Filename, vid_filename: Filename, sub_filename: Filename, opt_sub_filename: OptFilename, deck_name: str): super().__init__(title='Asts - Anki Card Generator', application=app, transient_for=parent) self.set_default_size(width=1000, height=700) self.set_keep_above(True) self.set_modal(True) self.set_resizable(False) setBgColor(widget=self, alpha=0.93) self._main_box: Box = Box() self._main_box.set_orientation(Orientation.VERTICAL) setMargin(self._main_box, 10) self.add(self._main_box) self._subtitles_grid: Grid = Grid() setMargin(self._subtitles_grid, 5) # box.pack_(expand, fill, padding) self._main_box.pack_start(self._subtitles_grid, False, True, 0) self._collection_filename: Filename = col_filename self._video_filename: Filename = vid_filename self._subtitles_filename: Filename = sub_filename self._opt_subtitles_filename: OptFilename = opt_sub_filename self._deck_name: str = deck_name self._any_media_toggled: bool = False self._dict_any_media: Dict[str, bool] self._dict_any_change_front: Dict[str, bytes] self._dict_any_change_back: Dict[str, bytes] self._textview_front: TextView self._textview_back: TextView self._textbuffer_front: TextBuffer self._textbuffer_back: TextBuffer self._subtitles_liststore: ListStore self._subtitles_liststore_back: ListStore self._subtitles_treeview: TreeView self._selected_row: TreeSelection self._progress_bar: ProgressBar self._cancel_btn: Button self._generate_btn: Button self._cur_progress: int self._max_tasks: int self._cancel_task: bool self._list_of_sentences: ListSentences self._list_info_medias: List[List[Info]] self._color_tag_names: List[str] # TheadingHandler will utilize these # updating the status for each task tasks # also the sensitive and progress of the progress bar # depends on these. self._futures_list: List[Future] def showAll(self) -> None: """ Draws the cards generator window and it's respective widgets. :return: """ # subtitles tree view self._setSubtitleTreeView() # indice and dialogue cells self._setDialogCells() # start and end timer cells self._setTimerCells() # video, audio and image cells self._setMediasCells() # fills both tree view with the subtitles self._populateListStore() # setting the model after and initializing _selected_row and _dict_any_media # after the liststore being complete initialized self._subtitles_treeview.set_model(self._subtitles_liststore) self._selected_row = self._subtitles_treeview.get_selection() self._selected_row.connect('changed', self._itemSelected) self._dict_any_media = { str(key): False for key in enumerate(self._subtitles_liststore) } # search entry self._setSearchEntry() # sets up the sentence editing related (e.g toolbar, tagging, etc) self._setSentenceRelated() # all color tags are named as it's respective values self._color_tag_names = [ '#9999c1c1f1f1', '#6262a0a0eaea', '#35358484e4e4', '#1c1c7171d8d8', '#1a1a5f5fb4b4', '#8f8ff0f0a4a4', '#5757e3e38989', '#3333d1d17a7a', '#2e2ec2c27e7e', '#2626a2a26969', '#f9f9f0f06b6b', '#f8f8e4e45c5c', '#f6f6d3d32d2d', '#f5f5c2c21111', '#e5e5a5a50a0a', '#ffffbebe6f6f', '#ffffa3a34848', '#ffff78780000', '#e6e661610000', '#c6c646460000', '#f6f661615151', '#eded33333b3b', '#e0e01b1b2424', '#c0c01c1c2828', '#a5a51d1d2d2d', '#dcdc8a8adddd', '#c0c06161cbcb', '#91914141acac', '#81813d3d9c9c', '#616135358383', '#cdcdabab8f8f', '#b5b583835a5a', '#98986a6a4444', '#86865e5e3c3c', '#636345452c2c', '#ffffffffffff', '#f6f6f5f5f4f4', '#dededddddada', '#c0c0bfbfbcbc', '#9a9a99999696', '#777776767b7b', '#5e5e5c5c6464', '#3d3d38384646', '#24241f1f3131', '#000000000000', ] # sets up dictionary used to track the tags used self._initDictionariesTag() # sets up the buttons to select all sentences self._setSelectAll() # sets up the progress bar self._setProgressBar() # cancel and generate buttonsj self._resetFuturesLists() self._setButtons() self.show_all() def _resetFuturesLists(self) -> None: """ Assign a empty list of both lists of futures (futures_setences and futures_medias). :return: """ self._futures_list = [] def _setSearchEntry(self) -> None: """ Connect the changed event for the search_entry object. :return: """ search_entry: SearchEntry = SearchEntry() search_entry.set_halign(Align.END) setMargin(search_entry, 0, 5, 0, 5) self._subtitles_grid.attach(search_entry, 0, 0, 1, 1) search_entry.connect('changed', self.searchIt) def searchIt(self, search_entry: SearchEntry) -> None: """ Searchs over the _subtitles_liststore. :return: """ term_searched: str = search_entry.get_text() for i, term in enumerate(self._subtitles_liststore): if term_searched and term_searched in term[1].lower(): self._subtitles_treeview.set_cursor(i) break def _setSelectAll(self) -> None: """ Sets up widgets to select all sentences. :return: """ grid: Grid = Grid() grid.set_halign(Align.END) self._subtitles_grid.attach(grid, 0, 2, 1, 1) lbl: Label = Label(label='Select all') setMargin(lbl, 5) grid.attach(lbl, 0, 0, 1, 1) all_vid_toggle: CheckButton = CheckButton() all_vid_toggle.set_halign(Align.CENTER) all_vid_toggle.connect('toggled', self._onAllVideosToggled) setMargin(all_vid_toggle, 5) grid.attach(all_vid_toggle, 1, 0, 1, 1) lbl2: Label = Label(label='Videos') setMargin(lbl2, 5) grid.attach(lbl2, 1, 1, 1, 1) all_audio_toggle: CheckButton = CheckButton() all_audio_toggle.set_halign(Align.CENTER) all_audio_toggle.connect('toggled', self._onAllAudiosToggled, all_vid_toggle) setMargin(all_audio_toggle, 5) grid.attach(all_audio_toggle, 2, 0, 1, 1) lbl3: Label = Label(label='Audios') setMargin(lbl3, 5) grid.attach(lbl3, 2, 1, 1, 1) all_img_toggle: CheckButton = CheckButton() all_img_toggle.set_halign(Align.CENTER) all_img_toggle.connect('toggled', self._onAllImagesToggled) setMargin(all_img_toggle, 5) grid.attach(all_img_toggle, 3, 0, 1, 1) lbl4: Label = Label(label='Snapshot') setMargin(lbl4, 5) grid.attach(lbl4, 3, 1, 1, 1) def _onAllVideosToggled(self, _) -> None: """ Handle the toggled event for the ToggleButton object. :param widget: ToggleButton object. :return: """ for i in range(len(self._subtitles_liststore)): if self._subtitles_liststore[i][5]: self._subtitles_liststore[i][ 5] = not self._subtitles_liststore[i][5] self._subtitles_liststore[i][ 4] = not self._subtitles_liststore[i][4] self._dict_any_media[str(i)] = self._subtitles_liststore[i][4] elif self._subtitles_liststore[i][6]: self._subtitles_liststore[i][ 6] = not self._subtitles_liststore[i][6] self._subtitles_liststore[i][ 4] = not self._subtitles_liststore[i][4] self._dict_any_media[str(i)] = self._subtitles_liststore[i][4] else: self._subtitles_liststore[i][ 4] = not self._subtitles_liststore[i][4] self._dict_any_media[str(i)] = self._subtitles_liststore[i][4] if True in self._dict_any_media.values(): self._any_media_toggled = True else: self._any_media_toggled = False def _onAllAudiosToggled(self, _) -> None: """ Handle the toggled event for the ToggleButton object. :param widget: ToggleButton object. :return: """ for i in range(len(self._subtitles_liststore)): if self._subtitles_liststore[i][4]: self._subtitles_liststore[i][ 4] = not self._subtitles_liststore[i][4] self._subtitles_liststore[i][ 5] = not self._subtitles_liststore[i][5] self._dict_any_media[str(i)] = self._subtitles_liststore[i][5] elif self._subtitles_liststore[i][5] and self._subtitles_liststore[ i][6]: self._subtitles_liststore[i][ 5] = not self._subtitles_liststore[i][5] self._dict_any_media[str(i)] = self._subtitles_liststore[i][6] else: self._subtitles_liststore[i][ 5] = not self._subtitles_liststore[i][5] self._dict_any_media[str(i)] = self._subtitles_liststore[i][5] if True in self._dict_any_media.values(): self._any_media_toggled = True else: self._any_media_toggled = False def _onAllImagesToggled(self, _) -> None: """ Handle the toggled event for the ToggleButton object. :param widget: ToggleButton object. :return: """ for i in range(len(self._subtitles_liststore)): if self._subtitles_liststore[i][4]: self._subtitles_liststore[i][ 4] = not self._subtitles_liststore[i][4] self._subtitles_liststore[i][ 6] = not self._subtitles_liststore[i][6] self._dict_any_media[str(i)] = self._subtitles_liststore[i][6] else: self._subtitles_liststore[i][ 6] = not self._subtitles_liststore[i][6] self._dict_any_media[str(i)] = self._subtitles_liststore[i][6] if True in self._dict_any_media.values(): self._any_media_toggled = True else: self._any_media_toggled = False def _initDictionariesTag(self) -> None: """ Init the default values for the used tags. :return: """ # dictionaries to track the tags self._dict_any_change_front = ({ str(key): serializeIt(text_buffer=self._textbuffer_front, tmp_string=value[1]) for key, value in enumerate(self._subtitles_liststore) }) self._dict_any_change_back = ({ str(key): serializeIt(text_buffer=self._textbuffer_back, tmp_string=value[1]) for key, value in enumerate(self._subtitles_liststore_back) }) def _populateListStore(self) -> None: """ Fills both list store (front and back) with subtitles. :return: """ self._subtitles_liststore = ListStore( int, # indice str, # dialogue str, # start timer str, # end timer bool, # whether video is selected bool, # whether audio is selected bool # whether image is selected ) # only the first two values are important here self._subtitles_liststore_back = ListStore(int, str, str, str, bool, bool, bool) dialogues_list: List[List[Info]] = extractAllDialogues( self._subtitles_filename) for dialogue in dialogues_list: self._subtitles_liststore.append(dialogue) if self._opt_subtitles_filename: opt_dialogues_list: List[List[Info]] = extractAllDialogues( self._opt_subtitles_filename) # the subtitles and their respective translations # may or may not be of same lenght # in that case fill the list with dummy values for i in range(len(dialogues_list)): try: self._subtitles_liststore_back.append( opt_dialogues_list[i]) except IndexError: self._subtitles_liststore_back.append( (i, '', '', '', False, False, False)) else: # in case no subtitles was selected for the back list store # fill it with dummy values for i in range(len(dialogues_list)): self._subtitles_liststore_back.append( (i, '', '', '', False, False, False)) def _setTimerCells(self) -> None: """ Arrange the start and end timer cells. :return: """ # Making some cells editable 'Start' and 'End' respectivily editable_start_field: CellRendererText = CellRendererText() editable_end_field: CellRendererText = CellRendererText() editable_start_field.set_property('editable', True) editable_end_field.set_property('editable', True) self._subtitles_treeview.append_column( TreeViewColumn(title='Start', cell_renderer=editable_start_field, text=2)) self._subtitles_treeview.append_column( TreeViewColumn(title='End', cell_renderer=editable_end_field, text=3)) editable_start_field.connect('edited', self._startFieldEdited) editable_end_field.connect('edited', self._endFieldEdited) def _startFieldEdited(self, _, path: TreePath, text: str) -> None: """ Handle the edited event for the start timer field cell. :widget: CellRendererText object. :path: TreePath object. :text: A string to be assigned to subtitles_liststore. :return: """ from re import compile, Pattern regex_timer: Pattern[str] = compile( r'([0-9][0-9]:[0-9][0-9]:[0-9][0-9].[0-9][0-9][0-9])') result = regex_timer.findall(text) if result: self._subtitles_liststore[path][2] = result[0] def _endFieldEdited(self, _, path: TreePath, text: str) -> None: """ Handle the edited event for the end timer field cell. :widget: CellRendererText object. :path: TreePath object. :text: A string to be assigned to subtitles_liststore. :return: """ from re import compile, Pattern regex_timer: Pattern[str] = compile( r'([0-9]?[0-9][0-9]:[0-9][0-9]:[0-9][0-9].[0-9][0-9][0-9])') result: List[str] = regex_timer.findall(text) if result: self._subtitles_liststore[path][3] = result[0] def _setDialogCells(self) -> None: """ Arrange the dialogue and indice cell at the treeview. :return: """ for i, title in enumerate(['Indice', 'Dialog']): renderer: CellRendererText = CellRendererText() path_column: TreeViewColumn = TreeViewColumn( title=title, cell_renderer=renderer, text=i) if title == 'Dialog': path_column.set_sizing(TreeViewColumnSizing.FIXED) path_column.set_fixed_width(520) path_column.set_min_width(520) self._subtitles_treeview.append_column(path_column) def _setMediasCells(self) -> None: """ Arrange the video, audio and snapshot cells. :return: """ # cell video, audio and snapshot to toggle renderer_video_toggle: CellRendererToggle = CellRendererToggle() column_toggle = TreeViewColumn(title='Video', cell_renderer=renderer_video_toggle, active=4) self._subtitles_treeview.append_column(column_toggle) renderer_video_toggle.connect("toggled", self._onCellVideoToggled) renderer_audio_toggle: CellRendererToggle = CellRendererToggle() column_toggle = TreeViewColumn(title='Audio', cell_renderer=renderer_audio_toggle, active=5) self._subtitles_treeview.append_column(column_toggle) renderer_audio_toggle.connect("toggled", self._onCellAudioToggled) renderer_snapshot_toggle: CellRendererToggle = CellRendererToggle() column_toggle = TreeViewColumn(title='Snapshot', cell_renderer=renderer_snapshot_toggle, active=6) self._subtitles_treeview.append_column(column_toggle) renderer_snapshot_toggle.connect("toggled", self._onCellImageToggled) def _onCellVideoToggled(self, _, path) -> None: """ Handles the toggled event for the CellRendererToggle object. :param widget: CellRendererToggle object. :path path: TreePath object. :return: """ if self._subtitles_liststore[path][5]: self._subtitles_liststore[path][ 5] = not self._subtitles_liststore[path][5] self._subtitles_liststore[path][ 4] = not self._subtitles_liststore[path][4] self._dict_any_media[path] = self._subtitles_liststore[path][4] elif self._subtitles_liststore[path][6]: self._subtitles_liststore[path][ 6] = not self._subtitles_liststore[path][6] self._subtitles_liststore[path][ 4] = not self._subtitles_liststore[path][4] self._dict_any_media[path] = self._subtitles_liststore[path][4] else: self._subtitles_liststore[path][ 4] = not self._subtitles_liststore[path][4] self._dict_any_media[path] = self._subtitles_liststore[path][4] if True in self._dict_any_media.values(): self._any_media_toggled = True else: self._any_media_toggled = False def _onCellAudioToggled(self, _, path: str) -> None: """ Handles the toggled event for the CellRendererToggle object. :param widget: CellRendererToggle object. :path path: TreePath object. :return: """ if self._subtitles_liststore[path][4]: self._subtitles_liststore[path][ 4] = not self._subtitles_liststore[path][4] self._subtitles_liststore[path][ 5] = not self._subtitles_liststore[path][5] self._dict_any_media[path] = self._subtitles_liststore[path][5] elif self._subtitles_liststore[path][5] and self._subtitles_liststore[ path][6]: self._subtitles_liststore[path][ 5] = not self._subtitles_liststore[path][5] self._dict_any_media[path] = self._subtitles_liststore[path][6] else: self._subtitles_liststore[path][ 5] = not self._subtitles_liststore[path][5] self._dict_any_media[path] = self._subtitles_liststore[path][5] if True in self._dict_any_media.values(): self._any_media_toggled = True else: self._any_media_toggled = False def _onCellImageToggled(self, _, path: str) -> None: """ Handles the toggled event for the CellRendererToggle object. :param widget: CellRendererToggle object. :path path: TreePath object. :return: """ if self._subtitles_liststore[path][4]: self._subtitles_liststore[path][ 4] = not self._subtitles_liststore[path][4] self._subtitles_liststore[path][ 6] = not self._subtitles_liststore[path][6] self._dict_any_media[path] = self._subtitles_liststore[path][6] elif self._subtitles_liststore[path][6] and self._subtitles_liststore[ path][5]: self._subtitles_liststore[path][ 6] = not self._subtitles_liststore[path][6] self._dict_any_media[path] = self._subtitles_liststore[path][5] else: self._subtitles_liststore[path][ 6] = not self._subtitles_liststore[path][6] self._dict_any_media[path] = self._subtitles_liststore[path][6] if True in self._dict_any_media.values(): self._any_media_toggled = True else: self._any_media_toggled = False def _setSubtitleTreeView(self) -> None: """ Sets the scrolled window and a tree view for subtitles info. :return: """ self._subtitles_treeview = TreeView() self._subtitles_treeview.set_grid_lines(TreeViewGridLines.BOTH) scrl_wnd: ScrolledWindow = ScrolledWindow() scrl_wnd.set_hexpand(True) scrl_wnd.set_vexpand(True) scrl_wnd.add(self._subtitles_treeview) self._subtitles_grid.attach(scrl_wnd, 0, 1, 1, 1) def _itemSelected(self, _) -> None: """ Keeps tracks of selections change at the treeview object. :return: """ path: str = self._selected_row.get_selected_rows()[1][0].to_string() deserializeIt(self._textbuffer_front, self._dict_any_change_front[path]) deserializeIt(self._textbuffer_back, self._dict_any_change_back[path]) self._textbuffer_front.connect('changed', self._editingCard) self._textbuffer_back.connect('changed', self._editingCardBack) def _editingCard(self, textbuffer_front: TextBuffer) -> None: """ Keeps track of changes at the text_buffer_front. :param text_buffer_front: TextBuffer object. :return: """ path: TreePath = self._selected_row.get_selected_rows()[1][0] start_iter_front: TextIter = textbuffer_front.get_start_iter() end_iter_front: TextIter = textbuffer_front.get_end_iter() self._subtitles_liststore[path][1] = textbuffer_front.get_text( start_iter_front, end_iter_front, True) self._dict_any_change_front[path.to_string()] = serializeIt( text_buffer=textbuffer_front) def _editingCardBack(self, textbuffer_back: TextBuffer) -> None: """ Keeps track of changes at the text_buffer_back. :param text_buffer_back: TextBuffer object. :return: """ path: TreePath = self._selected_row.get_selected_rows()[1][0] start_iter_back: TextIter = textbuffer_back.get_start_iter() end_iter_back: TextIter = textbuffer_back.get_end_iter() self._subtitles_liststore_back[path][1] = textbuffer_back.get_text( start_iter_back, end_iter_back, True) self._dict_any_change_back[path.to_string()] = serializeIt( text_buffer=textbuffer_back) def _setSentenceRelated(self) -> None: """ Sets up the sentence editing widgets related. Also initialize both text buffers. :return: """ box: Box = Box() self._main_box.pack_start(box, False, True, 0) box.set_orientation(Orientation.VERTICAL) setMargin(box, 5) toolbar: Toolbar = Toolbar() box.pack_start(toolbar, False, True, 0) toolbar.set_halign(Align.END) setMargin(toolbar, 5) lbl: Label = Label() lbl.set_markup('<i><b>Front</b></i>') box.pack_start(lbl, False, True, 0) lbl.set_halign(Align.START) setMargin(lbl, 5) scrl_wnd: ScrolledWindow = ScrolledWindow() scrl_wnd.set_hexpand(True) scrl_wnd.set_vexpand(True) textview: TextView = TextView() scrl_wnd.add(textview) box.pack_start(scrl_wnd, False, True, 0) self._textbuffer_front = textview.get_buffer() lbl2: Label = Label() lbl2.set_halign(Align.START) lbl2.set_markup('<i><b>Back</b></i>') box.pack_start(lbl2, False, True, 0) setMargin(lbl2, 5) scrl_wnd2: ScrolledWindow = ScrolledWindow() scrl_wnd2.set_hexpand(True) scrl_wnd2.set_vexpand(True) textview2: TextView = TextView() scrl_wnd2.add(textview2) box.pack_end(scrl_wnd2, False, True, 0) self._textbuffer_back = textview2.get_buffer() # this depends on the text buffer to be initialized self._setToolbarColorButton(toolbar) toolbar.insert(SeparatorToolItem(), 3) self._setToolbarUnderlineButton(toolbar) self._setToolbarBoldButton(toolbar) self._setToolbarItalicButton(toolbar) toolbar.insert(SeparatorToolItem(), 7) self._setToolbarTagRemoverButton(toolbar) def _setToolbarColorButton(self, toolbar: Toolbar) -> None: """ Sets up the color button from the toolbar. :param toolbar: Toolbar object :return: """ set_color_button: ToolButton = ToolButton() set_color_button.set_icon_name('gtk-select-color') toolbar.insert(set_color_button, 1) tool_item_color_button: ToolItem = ToolItem() color_button = ColorButton() tool_item_color_button.add(color_button) toolbar.insert(tool_item_color_button, 2) set_color_button.connect('clicked', self._onToolbarColorBtnClicked, color_button) def _setToolbarUnderlineButton(self, toolbar: Toolbar) -> None: """ Sets up the underline button from the toolbar. :param toolbar: Toolbar object :return: """ tag_underline_front: TextTag = self._textbuffer_front.create_tag( 'underline', underline=Underline.SINGLE) tag_underline_back: TextTag = self._textbuffer_back.create_tag( 'underline', underline=Underline.SINGLE) button_underline: ToolButton = ToolButton() button_underline.set_icon_name('format-text-underline-symbolic') toolbar.insert(button_underline, 4) button_underline.connect('clicked', self._onToolbarTagBtnClicked, tag_underline_front, tag_underline_back) def _setToolbarBoldButton(self, toolbar: Toolbar) -> None: """ Sets up the bold button from the toolbar. :param toolbar: Toolbar object :return: """ tag_bold_front: TextTag = self._textbuffer_front.create_tag( 'bold', weight=Weight.BOLD) tag_bold_back: TextTag = self._textbuffer_back.create_tag( 'bold', weight=Weight.BOLD) button_bold: ToolButton = ToolButton() button_bold.set_icon_name('format-text-bold-symbolic') toolbar.insert(button_bold, 5) button_bold.connect('clicked', self._onToolbarTagBtnClicked, tag_bold_front, tag_bold_back) def _setToolbarItalicButton(self, toolbar: Toolbar) -> None: """ Sets up the italic button from the toolbar. :param toolbar: Toolbar object :return: """ tag_italic_front: TextTag = self._textbuffer_front.create_tag( 'italic', style=Style.ITALIC) tag_italic_back: TextTag = self._textbuffer_back.create_tag( 'italic', style=Style.ITALIC) button_italic: ToolButton = ToolButton() button_italic.set_icon_name('format-text-italic-symbolic') toolbar.insert(button_italic, 6) button_italic.connect('clicked', self._onToolbarTagBtnClicked, tag_italic_front, tag_italic_back) def _setToolbarTagRemoverButton(self, toolbar: Toolbar) -> None: """ Sets up the tag remover button from the toolbar. :param toolbar: Toolbar object. :return: """ button_remove_all_tags: ToolButton = ToolButton() button_remove_all_tags.set_icon_name('edit-clear-symbolic') toolbar.insert(button_remove_all_tags, 8) button_remove_all_tags.connect( 'clicked', lambda _: self._removeAllTagsFromSelection()) def _getBounds(self) -> Tuple[TextMark, TextMark, Optional[str]]: """ Returns the selection of the text in the text buffer. :return: A tuple with the textiter of the selection and the path string. """ path: Optional[str] # if no row is selected # a IndexError will be raised try: path = self._selected_row.get_selected_rows()[1][0].to_string() except IndexError: path = None bounds_front: TextMark = self._textbuffer_front.get_selection_bounds() bounds_back: TextMark = self._textbuffer_back.get_selection_bounds() return (bounds_front, bounds_back, path) def _onToolbarColorBtnClicked(self, _, color_button: ColorButton) -> None: """ Handles the clicked event for the tool_item_color_button. :param set_color_button: ToolButton object. :param color_button: ColorButton object. :return: """ start: TextIter end: TextIter bounds_front: TextMark bounds_back: TextMark path: Optional[str] color: str = color_button.get_color().to_string() tag_table_front: TextTagTable = self._textbuffer_front.get_tag_table() tag_table_back: TextTagTable = self._textbuffer_back.get_tag_table() (bounds_front, bounds_back, path) = self._getBounds() # no selected row so there's nothing to do if not path: return ##### FRONT if bounds_front: (start, end) = bounds_front # only the first color applied to the selection # will be present at the final card # so remove all color previously applied to the current selected text. self._removeAllTagsFromSelection(color_tags=True) if not tag_table_front.lookup(color): tag_front: TextTag = self._textbuffer_front.create_tag( color, foreground=color) self._textbuffer_front.apply_tag(tag_front, start, end) else: self._textbuffer_front.apply_tag_by_name(color, start, end) self._dict_any_change_front[path] = serializeIt( text_buffer=self._textbuffer_front) ###### BACK if bounds_back: (start, end) = bounds_back # only the first color applied to the selected text # will be present at the final card # so remove all color previously applied to the current selected text. self._removeAllTagsFromSelection(color_tags=True) if not tag_table_back.lookup(color): tag_back = self._textbuffer_back.create_tag(color, foreground=color) self._textbuffer_back.apply_tag(tag_back, start, end) else: self._textbuffer_back.apply_tag_by_name(color, start, end) self._dict_any_change_back[path] = serializeIt( text_buffer=self._textbuffer_back) def _onToolbarTagBtnClicked(self, _, tag_front: TextTag, tag_back: TextTag) -> None: """ Handles the clicked event for the tool button. :param widget: ToolButton object. :param tag_front: TextTag object. :param tag_back: TextTag object. :return: """ start: TextIter end: TextIter bounds_front: TextMark bounds_back: TextMark path: Optional[str] (bounds_front, bounds_back, path) = self._getBounds() # no selected row so there's nothing to do if not path: return ##### FRONT if bounds_front: (start, end) = bounds_front self._textbuffer_front.apply_tag(tag_front, start, end) self._dict_any_change_front[path] = serializeIt( text_buffer=self._textbuffer_front) ###### BACK if bounds_back: (start, end) = bounds_back self._textbuffer_back.apply_tag(tag_back, start, end) self._dict_any_change_back[path] = serializeIt( text_buffer=self._textbuffer_back) def _removeAllTagsFromSelection(self, color_tags: bool = False) -> None: """ Remove all tags from the current selected text. :param color_tags: If true only removes color tags. :return: """ start: TextIter end: TextIter bounds_front: TextMark bounds_back: TextMark path: Optional[str] tag_table_front: TextTagTable = self._textbuffer_front.get_tag_table() tag_table_back: TextTagTable = self._textbuffer_back.get_tag_table() (bounds_front, bounds_back, path) = self._getBounds() # no selected row so there's nothing to do if not path: return ### FRONT if bounds_front: (start, end) = bounds_front if color_tags: for c in self._color_tag_names: if tag_table_front.lookup(c): self._textbuffer_front.remove_tag_by_name( c, start, end) else: self._textbuffer_front.remove_all_tags(start, end) self._dict_any_change_front[path] = serializeIt( text_buffer=self._textbuffer_front) ### BACK if bounds_back: (start, end) = bounds_back if color_tags: for c in self._color_tag_names: if tag_table_back.lookup(c): self._textbuffer_back.remove_tag_by_name(c, start, end) else: self._textbuffer_back.remove_all_tags(start, end) self._dict_any_change_back[path] = serializeIt( text_buffer=self._textbuffer_back) def _setProgressBar(self) -> None: """ Sets up the progress bar. :return: """ self._cur_progress = 0 self._progress_bar = ProgressBar() setMargin(self._progress_bar, 5) self._main_box.pack_start(self._progress_bar, False, True, 0) def _setButtons(self) -> None: """ Sets up the cancel and generate buttons. :return: """ box: Box = Box() self._main_box.pack_end(box, False, True, 0) box.set_halign(Align.CENTER) box.set_orientation(Orientation.HORIZONTAL) setMargin(box, 5) self._cancel_btn = Button(label='Cancel') box.pack_start(self._cancel_btn, False, True, 0) setMargin(self._cancel_btn, 5, 5, 100, 5) self._cancel_btn.connect('clicked', self._onCancelBtnClicked) self._generate_btn = Button(label='Generate') box.pack_end(self._generate_btn, False, True, 0) setMargin(self._generate_btn, 100, 5, 5, 5) self._generate_btn.connect('clicked', self._onGenerateBtnClicked) timeout_add(300, self._setSensitiveGenerateBtn) def _setSensitiveGenerateBtn(self) -> bool: """ Set the senstive for the generate_btn. :return: A boolean to signal whether idle_add should remove it from list event. """ if self._cur_progress or not self._allFuturesDone(): self._generate_btn.set_sensitive(False) elif not self._any_media_toggled: self._generate_btn.set_sensitive(False) else: self._generate_btn.set_sensitive(True) return True def _allFuturesDone(self) -> bool: """ Check for the status of futures. :return: Return true if all futures are done. """ for f in self._futures_list: if not f.done(): return False return True def _updateProgress(self) -> bool: """ Keep track of the objects yet to be completed. Updates the progress bar. :param future: Parameter passed by add_done_callback. :return: a boolean to signal whether idle_add should remove it from list event. """ if not self.getCancelTaskStatus(): self._cur_progress += 1 self._progress_bar.set_fraction(self._cur_progress / self._max_tasks) self._progress_bar.set_text(None) self._progress_bar.set_show_text(True) if self._cur_progress == self._max_tasks: self._cur_progress = 0 self._progress_bar.set_text('Done!') self._progress_bar.set_show_text(True) return False def resetProgressbar(self) -> None: """ Resets the progress bar back to zero. :return: """ self._cur_progress = 0 self._progress_bar.set_fraction(self._cur_progress) self._progress_bar.set_show_text(False) def idleaddUpdateProgress(self, _) -> None: """ Call idle_add to call updateProgress. :param future: Optional future object. :return: """ idle_add(self._updateProgress) def getCancelTaskStatus(self) -> bool: """ Get the status for the cancel_task. :return: Return true if the task should be cancelled. """ return self._cancel_task def setCancelTaskStatus(self, status: bool) -> None: """ Set the status for the cancel_task. :return: """ self._cancel_task = status def _idleaddUpdateProgress(self, _) -> None: """ Call idle_add to call updateProgress. :param future: Optional future object. :return: """ idle_add(self._updateProgress) def _setSensitiveCancelBtn(self) -> bool: """ Set the sensitive for snd_cancel_button. :return: """ if self._allFuturesDone(): self._progress_bar.set_text('Canceled!') self._cancel_btn.set_sensitive(True) return False else: self._progress_bar.set_text('Cancelling please wait...') self._cancel_btn.set_sensitive(False) return True def _onCancelBtnClicked(self, _) -> None: """ Handle the clicked event for the second_cancel_button button. :param widget: Button object. :return: """ if not self._cur_progress: self._generate_btn.set_sensitive(True) self.close() else: self.setCancelTaskStatus(True) self._cur_progress = 0 self._progress_bar.set_fraction(self._cur_progress) self._progress_bar.set_show_text(True) timeout_add(300, self._setSensitiveCancelBtn) self._cur_progress = 0 self._progress_bar.set_fraction(self._cur_progress) def _onGenerateBtnClicked(self, _) -> None: """ Handle the click event for the generate_btn. :return: """ from asts.Threading import ThreadingHandler self._listMediasSentences() ThreadingHandler(self) def _listMediasSentences(self) -> None: """ Create two lists and fill them with filenames and sentences. :return: """ from uuid import uuid1 from asts.Utils import PangoToHtml # case other tasks already had been scheduled self._resetFuturesLists() self._list_of_sentences = [] self._list_info_medias = [] p: PangoToHtml = PangoToHtml() for i in range(len(self._subtitles_liststore)): if self._subtitles_liststore[i][4] or self._subtitles_liststore[i][ 5] or self._subtitles_liststore[i][6]: # a unique id for each media, some images will conflict if it has the same name as a image # on anki media collection uuid_media = uuid1().int text_front: str = p.feed(self._dict_any_change_front[str(i)]) text_back: str = p.feed(self._dict_any_change_back[str(i)]) self._list_info_medias.append( [str(uuid_media)] + (self._subtitles_liststore[i][1:])) if self._subtitles_liststore[i][ 4] and not self._subtitles_liststore[i][6]: self._list_of_sentences.append( (text_front, text_back, f'{uuid_media}.mp4', None, None)) elif self._subtitles_liststore[i][ 5] and self._subtitles_liststore[i][6]: self._list_of_sentences.append( (text_front, text_back, None, f'{uuid_media}.mp3', f'{uuid_media}.bmp')) elif self._subtitles_liststore[i][ 5] and not self._subtitles_liststore[i][6]: self._list_of_sentences.append( (text_front, text_back, None, f'{uuid_media}.mp3', None)) else: self._list_of_sentences.append( (text_front, text_back, None, None, f'{uuid_media}.bmp')) self._max_tasks = len(self._list_info_medias) + len( self._list_of_sentences) def getCollection(self) -> Filename: """ Returns the filename for the anki2.collection. :return: Filename of the anki2.collection. """ return self._collection_filename def getDeckName(self) -> str: """ Returns the deck name. :return: Deck name. """ return self._deck_name def getVideoFilename(self) -> Filename: """ Returns the name of the video file. :return: Video filename. """ return self._video_filename def getListInfoMedias(self) -> List[List[Info]]: """ Returns a list with information about each media to be used at creating cards. :return: A list with information about each media. """ return self._list_info_medias def getListOfSentences(self) -> ListSentences: """ Returns a List with information about each sentence to be used at creating cards. :return: A list with information about each sentence. """ return self._list_of_sentences def appendFuture(self, future: Future) -> None: """ Append the future to _futures_list. :return: """ self._futures_list.append(future)
def _do_button_press(self, w: Gtk.TreeView, e: Gdk.EventButton): if e.type == Gdk.EventType.DOUBLE_BUTTON_PRESS: path = w.get_path_at_pos(e.x, e.y) if path is not None: self.response(Gtk.ResponseType.OK)
def __init__(self, tree_view: Gtk.TreeView): self.log = logging.getLogger('{m}.{c}'.format( m=self.__class__.__module__, c=self.__class__.__name__)) tree_view.connect('key-press-event', self.on_key_press_event)
def __init__(self, *args, **kwargs): TreeView.__init__(self, *args, **kwargs)