def new_book(self, doc_stream, good_stream, bad_stream): self.book_name = doc_stream.filename() self.editv.book_renamed(self.book_name) self.book_folder = doc_stream.folderpath() self.book_full_path = doc_stream.fullpath() self.editm.setPlainText(doc_stream.readAll()) self.editm.setModified(True) # If there are good_words and bad_words streams, call the worddata # metadata reader functions directly to accept them. if good_stream: self.wordm.good_file(good_stream) if bad_stream: self.wordm.bad_file(bad_stream) self.pagem.scan_pages() # develop page metadata if possible self.hook_images() # set up display of scan images if possible self.editv.set_cursor(self.editv.make_cursor(0, 0)) # cursor to top self._speller = dictionaries.Speller(self.dict_tag, self.book_folder) # Check the loaded text for \ufffd "replacement" chars indicating # mis-decoding of the file. findtc = self.editm.find(C.UNICODE_REPL, position=0) if not findtc.isNull(): m1 = _TR( 'File:Open finds bad encoding', 'This document contains at least one Unicode Replacement Character!' ) m2 = _TR( 'File: Open finds bad encoding', '''This indicates it was read with the wrong encoding! See the Help file under "File Encodings and File Names" The first bad character is at ''', 'integer follows this') + str( findtc.position()) utilities.warning_msg(m1, m2, self.mainwindow)
def _read_dict(self, sentinel, value, version): tag_dict = dictionaries.get_tag_list(self.book_folder) try: dict_path = tag_dict[value] # index error if value not a known tag speller = dictionaries.Speller(value, dict_path) if not speller.is_valid(): raise ValueError # we have a valid dictionary tag and spellcheck object self.dict_tag = value self._speller = speller except: self.logger.error( 'Unable to open default dictionary {0}, using default {1}'. format(value, self.dict_tag))
def ask_dictionary(self): tag_list = dictionaries.get_tag_list(self.book_folder) if 0 < len(tag_list): # dictionaries knows about at least one tag, display it/them item_list = sorted(list(tag_list.keys())) current = 0 if self.dict_tag in item_list: current = item_list.index(self.dict_tag) title = _TR("EditViewWidget", "Primary dictionary for this book", "Dictionary pop-up list") explanation = _TR( "EditViewWidget", "Select the best dictionary for spell-checking this book", "Dictionary pop-up list") new_tag = utilities.choose_from_list(title, explanation, item_list, parent=self.editv, current=current) if (new_tag is not None) and (new_tag != self.dict_tag): # a choice was made and it's different from before self.dict_tag = new_tag self._speller = dictionaries.Speller(new_tag, tag_list[new_tag]) self.wordm.recheck_spelling(self._speller) return True else: # no known dictionaries, probably the Extras have not been # configured -- tell user. utilities.warning_msg( text=_TR("EditViewWidget", "No dictionaries found", "Dictionary request warning"), info=_TR("EditViewWidget", "Perhaps the 'extras' folder is not defined?'", "Dictionary request info")) return False
assert T.check_log(".dic but not", logging.ERROR) os.remove(dic_path) # clean up Files # cause T.path_to_Files to have mismatched foobar.aff aff_path = os.path.join(T.path_to_Files, 'foobar.aff') f = open(aff_path, 'w') f.close() tag_list = dictionaries.get_tag_list(T.path_to_Files) assert T.check_log(".aff but not", logging.ERROR) os.remove(aff_path) # clean up Files # "skipping" should appear if we check a path twice tag_list = dictionaries.get_tag_list(test_dicts) assert T.check_log("Skipping", logging.INFO) # Check the spellcheck object: bad input makes not is_valid # and all words are ok SP = dictionaries.Speller("xx_YY", paths.get_dicts_path()) assert T.check_log('bad dictionary path', logging.ERROR) assert not SP.is_valid() assert SP.check('neenerneener', None) SP = None # get rid of that object SP = dictionaries.Speller("en_US", paths.get_dicts_path()) assert SP.is_valid() assert SP.check('raspberry', None) assert not SP.check('bazongas', None) assert SP.check('framboise', 'fr_FR') assert not SP.check('bazongas', 'fr_FR') # nonexistent alt tag produces True assert SP.check('bazongas', 'en_AU')
def __init__(self, sequence, the_main): super().__init__(None) # Save our mainwindow ref and our unique sequence number self.mainwindow = the_main self.sequence = sequence # Create our dict of activity panel objects, used by the main # window when giving us the focus. self.panel_dict = mainwindow.PANEL_DICT.copy() # Set up a book-unique logging channel self.logger = logging.getLogger(name='book_' + str(self.sequence)) # Create the spellchecker using the global default dictionary. It may # be recreated when we have a book path and/or read a preferred dict # tag from metadata. self.dict_tag = dictionaries.get_default_tag() self._speller = dictionaries.Speller(self.dict_tag, paths.get_dicts_path()) # Connect to find out about a change in the dicts path. paths.notify_me(self.path_change_slot) # Initialize slots for info about our book, which get filled in when # the mainwindow calls new_empty, old_book, or new_book below. self.edit_point_size = C.DEFAULT_FONT_SIZE self.edit_cursor = (0, 0) self.book_name = '' self.book_folder = '' self.book_full_path = '' self.last_find_button_path = '' # Initialize the metadata-modified flag, see metadata_modified() self.md_modified = 0 # Initialize bookmarks, loaded from metadata later. The bookmarks # are indexed 1-9 (from control-1 to control-9 keys) but the list # has ten entries, entry 0 not being used. self.bookmarks = [ None, None, None, None, None, None, None, None, None, None ] # Initialize the book-facts dict in case none is read from metadata. self.book_facts = { "Title": "?", "Author": "?", "Publication date": "1???", "Language": "English" } # # Create the metadata manager, then register to read and write the # metadata sections that are stored at this level: the last-set main # dictionary, the cursor position at save, the edit point size at # save, the bookmarks, the hash value of the saved document, and the # book_facts dictionary. # self.metamgr = metadata.MetaMgr() self.metamgr.register(C.MD_MD, self._read_dict, self._save_dict) self.metamgr.register(C.MD_CU, self._read_cursor, self._save_cursor) self.metamgr.register(C.MD_ES, self._read_size, self._save_size) self.metamgr.register(C.MD_BM, self._read_bookmarks, self._save_bookmarks) self.metamgr.register(C.MD_DH, self._read_hash, self._save_hash) self.metamgr.register(C.MD_BI, self._read_facts, self._save_facts) # # Create the data model objects. These are private to the book. self.editm = editdata.Document( self) # document, to be initialized later self.pagem = pagedata.PageData(self) # page data self.charm = chardata.CharData(self) # character data self.wordm = worddata.WordData(self) # vocabulary data self.fnotm = fnotdata.FnoteData(self) # footnote data # # Create the view objects that display and interact with the data # models. These need to be accessible to the main window for the # focus_me operation so are stored in the panel_dict. # self.editv = editview.EditView( self, lambda: self.mainwindow.focus_me(self.sequence)) self.imagev = imageview.ImageDisplay(self) # keep a short reference self.panel_dict['Images'] = self.imagev self.panel_dict['Notes'] = noteview.NotesPanel(self) self.panel_dict['Find'] = findview.FindPanel(self) self.panel_dict['Chars'] = charview.CharView(self) self.panel_dict['Words'] = wordview.WordPanel( self) # wordview.WordPanel(self) self.panel_dict['Pages'] = pageview.PagePanel( self) # pageview.PagePanel(self) self.panel_dict['Fnote'] = fnotview.FnotePanel( self) # fnotview.FnotePanel(self) self.panel_dict['Loupe'] = loupeview.LoupeView(self) self.panel_dict['tab_list'] = [ (tabname, self.panel_dict[tabname]) for tabname in self.panel_dict['default'] ]
def path_change_slot(self, what_path): if what_path == 'dicts': self._speller = dictionaries.Speller(self.dict_tag, self.book_folder)