def showDlg(self):
logger.debug(util.funcName(obj=self))
dlg = dutil.createDialog(self.unoObjs, _dlgdef)
if not dlg:
return
ctrl_getter = dutil.ControlGetter(dlg)
app = BulkConversion(self.unoObjs)
self.step1Form = FormStep1(ctrl_getter, app)
self.step1Form.start_working()
self.step2Form = FormStep2(ctrl_getter, app)
self.step2Form.start_working()
stepper = DlgStepper(dlg)
advancer = AdvanceHandler(
ctrl_getter, stepper, self.step1Form, self.step2Form)
advancer.start_working()
closingButtons = ClosingButtons(ctrl_getter, dlg.endExecute)
closingButtons.start_working()
## Display the dialog
dlg.execute()
if stepper.on_step1():
self.step1Form.store_results()
if stepper.on_step2():
self.step2Form.store_results()
if closingButtons.convertOnClose:
try:
app.doConversions()
except exceptions.MessageError as exc:
msgbox = MessageBox(self.unoObjs)
msgbox.displayExc(exc)
return
dlg.dispose()
def createDialog(uno_objs, definition_class):
""":param definition_class: class from lingt.utils.dlgdefs"""
logger.debug("Creating dialog...")
dlg_getter = DialogGetter(uno_objs, definition_class)
dlg = None
try:
dlg = dlg_getter.create_and_verify()
except exceptions.DialogError as exc:
msgbox = MessageBox(uno_objs)
msgbox.displayExc(exc)
return None
logger.debug("Created dialog.")
return dlg
class DlgMkoxtSettings:
"""Main class for this dialog."""
def __init__(self, unoObjs):
self.unoObjs = unoObjs
self.msgbox = MessageBox(self.unoObjs)
self.userVars = uservars.UserVars(uservars.Prefix.MAKE_OXT,
unoObjs.document, logger)
self.settings = None
self.runOnClose = False
self.dlgCtrls = None
self.evtHandler = None
self.dlgClose = None
def showDlg(self):
logger.debug(util.funcName(obj=self))
dlg = dutil.createDialog(self.unoObjs, _dlgdef)
if not dlg:
return
ctrl_getter = dutil.ControlGetter(dlg)
self.evtHandler = DlgEventHandler(self)
self.dlgCtrls = DlgControls(self.unoObjs, ctrl_getter, self.evtHandler,
self.userVars)
self.dlgCtrls.loadValues()
## Display the dialog
self.dlgClose = dlg.endExecute
dlg.execute()
if self.runOnClose:
_mkoxt(self.settings, self.msgbox)
dlg.dispose()
def closeAndRun(self):
logger.debug(util.funcName('begin'))
try:
self.settings = self.dlgCtrls.getFormResults()
self.runOnClose = True
self.dlgClose()
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
logger.debug(util.funcName('end'))
class DlgMkoxt:
"""Main class for this dialog."""
def __init__(self, unoObjs):
self.unoObjs = unoObjs
self.msgbox = MessageBox(self.unoObjs)
uservars.SettingsDocPreparer(uservars.Prefix.MAKE_OXT,
unoObjs).prepare()
self.userVars = uservars.UserVars(uservars.Prefix.MAKE_OXT,
unoObjs.document, logger)
self.settings = None
self.runOnClose = False
self.dlgCtrls = None
self.evtHandler = None
self.dlgClose = None
def showDlg(self):
logger.debug(util.funcName(obj=self))
dlg = dutil.createDialog(self.unoObjs, _dlgdef)
if not dlg:
return
ctrl_getter = dutil.ControlGetter(dlg)
self.evtHandler = DlgEventHandler(self)
self.dlgCtrls = DlgControls(self.unoObjs, ctrl_getter, self.evtHandler,
self.userVars)
self.evtHandler.setCtrls(self.dlgCtrls)
self.dlgCtrls.loadValues()
## Display the dialog
self.dlgClose = dlg.endExecute
dlg.execute()
if self.runOnClose:
_mkoxt(self.settings, self.msgbox)
filename = os.path.basename(self.settings.outfile)
self.msgbox.display("%s finished." % filename)
dlg.dispose()
def showFilePicker(self):
logger.debug(util.funcName('begin'))
OXT_EXT = ".oxt"
extension = OXT_EXT
defaultFilename = "MyLanguage" + extension
filters = [["OpenOffice Extension (%s)" % OXT_EXT, "*" + OXT_EXT]]
filepath = filepicker.showFilePicker(self.unoObjs, True, filters,
defaultFilename)
logger.debug(repr(filepath))
if filepath == "":
logger.debug("No filepath specified.")
return
if not filepath.lower().endswith(extension):
filepath = "{}{}".format(filepath, extension)
self.dlgCtrls.txtOutfile.setText(filepath)
logger.debug("set filepath to '%s'", filepath)
def closeAndRun(self):
logger.debug(util.funcName('begin'))
try:
self.settings = self.dlgCtrls.getFormResults()
self.settings.empty_to_none()
self.runOnClose = True
self.dlgClose()
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
logger.debug(util.funcName('end'))
class SpellingChecker:
"""Traverse words in a Writer document to check and make spelling
corrections. This is similar in concept to a traditional spell checker.
Calls DlgSpellingReplace from the UI layer.
"""
def __init__(self, writerUnoObjs, userVars):
self.unoObjs = writerUnoObjs
self.msgbox = MessageBox(self.unoObjs)
self.userVars = userVars
self.goodList = GoodList(self.msgbox)
self.wordAsker = WordAsker(self.unoObjs, self.goodList)
self.config = None
self.numChanges = 0
def setConfig(self, newConfig):
"""Param should be of type CheckerSettings."""
self.config = newConfig
self.wordAsker.setConfig(newConfig)
def doSearch(self):
"""Get text ranges and then check those ranges for words.
Navigate to each word (perhaps using punctuation list) and
verify each word against the word list.
"""
logger.debug(util.funcName('begin'))
try:
self.readWordList()
except (exceptions.FileAccessError, exceptions.DocAccessError) as exc:
self.msgbox.display(
"Error reading file %s", self.config.filepath)
return
rangesFound = self.getRanges()
self.numChanges = 0
try:
for txtRange in rangesFound:
self.changeTextRange(txtRange)
if self.config.whichTask == 'ApplyCorrections':
plural = "" if self.numChanges == 1 else "s"
self.msgbox.display(
"Made %d correction%s.", self.numChanges, plural)
else:
self.msgbox.display("Spell check finished.")
except exceptions.UserInterrupt:
pass
except exceptions.DocAccessError:
self.msgbox.display("Error writing to spreadsheet.")
except exceptions.RangeError as exc:
self.msgbox.displayExc(exc)
finally:
self.wordAsker.cleanup()
def changeTextRange(self, txtRange):
rangeJumper = RangeJumper(self.unoObjs)
rangeJumper.setTextRange(txtRange)
rangeTokens = getTokens(rangeJumper.getString())
tokenNum = -2 # because the loop starts by += 2
while True:
tokenNum += 2 # tokens are in pairs: word, delim
logger.debug("Token '%d' of %d", tokenNum, len(rangeTokens))
if tokenNum >= len(rangeTokens):
break
word = rangeTokens[tokenNum].strip(self.config.punctuation)
#word = re.sub(self.config.punct_expr, "", rangeTokens[tokenNum])
wordLower = self.goodList.firstLower(word)
wordNoAffix = self.wordAsker.removeAffixes(wordLower)
suspect = True
if not word:
suspect = False
elif word.isdigit() or word.isspace():
suspect = False
elif wordLower in self.goodList or wordNoAffix in self.goodList:
suspect = False
elif wordLower in self.wordAsker.wordsToIgnore:
suspect = False
if self.config.whichTask == 'ApplyCorrections':
suspect = wordLower in self.goodList.changeDict
if suspect:
logger.debug("Word '%s' is suspect", word)
try:
rangeJumper.selectWord(
"".join(rangeTokens[:tokenNum]),
rangeTokens[tokenNum])
except exceptions.RangeError:
if self.msgbox.displayOkCancel(
"Missed word '%s'. Keep going?", word):
continue
else:
raise exceptions.UserInterrupt()
if self.wordAsker.handleWord(
word, rangeTokens, tokenNum, rangeJumper):
self.numChanges += 1
rangeTokens = getTokens(rangeJumper.getString())
tokensBefore = getTokens(rangeJumper.getStringBefore())
tokenNum = len(tokensBefore)
tokenNum -= tokenNum % 2 # make sure it's even
def readWordList(self):
"""Read word list from Calc.
Sets self.changeDict if applying corrections.
"""
fileReader = spreadsheet_reader.CalcFileReader(self.unoObjs)
fileReader.loadDoc(self.config.filepath)
self.goodList.setCalcUnoObjs(fileReader.calcUnoObjs)
columnOrder = ColumnOrder(self.userVars)
columnOrder.loadUserVars()
if self.config.whichTask == 'SpellCheck':
logger.debug("Reading good list.")
columnLetter = columnOrder.getColLetter('colWord')
wordListReader = fileReader.getSpreadsheetReader()
wordList = wordListReader.getColumnStringList(
columnLetter, skipFirstRow=True)
self.goodList.setGoodList(
wordList, self.config.matchCase, self.config.normForm,
columnLetter)
else:
logger.debug("Reading change list.")
changeList = spellingchanges.getChangeList(
fileReader.calcUnoObjs, columnOrder)
for oldVal, newVal in changeList:
self.goodList.changeDict[
self.goodList.firstLower(oldVal)] = newVal
def getRanges(self):
progressBar = ProgressBar(self.unoObjs, "Finding text...")
progressBar.show()
progressBar.updateBeginning()
textSearch = TextSearch(self.unoObjs, progressBar)
textSearch.setConfig(self.config.searchConfig)
try:
if self.config.whichScope == 'WholeDoc':
textSearch.scopeWholeDocTraverse()
elif self.config.whichScope == 'Selection':
textSearch.scopeSelection()
elif self.config.whichScope == 'Language':
textSearch.scopeLocale()
elif self.config.whichScope == 'ParaStyle':
textSearch.scopeParaStyle()
elif self.config.whichScope == 'CharStyle':
textSearch.scopeCharStyle()
elif self.config.whichScope == 'Font':
textSearch.scopeFont()
elif self.config.whichScope == 'SFMs':
textSearch.scopeSFMs()
else:
raise exceptions.LogicError(
"Unexpected value %s", self.config.whichScope)
progressBar.updateFinishing()
except exceptions.MessageError as exc:
raise exc
finally:
progressBar.close()
return textSearch.getRanges()
class DlgGramSettings:
"""Main class for this dialog."""
def __init__(self, unoObjs):
self.unoObjs = unoObjs
self.userVars = uservars.UserVars(uservars.Prefix.GRAMMAR,
unoObjs.document, logger)
self.msgbox = MessageBox(unoObjs)
self.fileItems = fileitemlist.FileItemList(fileitemlist.LingExFileItem,
self.userVars)
self.selectedIndex = -1 # position in listboxFiles
self.dlgCtrls = None
self.evtHandler = None
self.dlgClose = None
def showDlg(self):
logger.debug(util.funcName(obj=self))
dlg = dutil.createDialog(self.unoObjs, _dlgdef)
if not dlg:
return
ctrl_getter = dutil.ControlGetter(dlg)
self.evtHandler = DlgEventHandler(self)
self.dlgCtrls = DlgControls(self.unoObjs, ctrl_getter, self.evtHandler)
self.evtHandler.setCtrls(self.dlgCtrls)
self.dlgCtrls.loadValues(self.userVars, self.fileItems)
self.dlgCtrls.enableDisable()
self.viewFile(False)
logger.debug("Finishing dialog creation")
self.dlgClose = dlg.endExecute
dlg.execute()
dlg.dispose()
def viewFile(self, checkForUpdates):
"""Handle selected list item."""
logger.debug(util.funcName('begin'))
if checkForUpdates:
newSelectedItem = self.dlgCtrls.listboxFiles.getSelectedItem()
logger.debug("newSelectedItem '%s'", newSelectedItem)
self.updateFile(False)
if newSelectedItem:
self.dlgCtrls.listboxFiles.selectItem(newSelectedItem, True)
try:
self.selectedIndex = dutil.get_selected_index(
self.dlgCtrls.listboxFiles, "a file")
logger.debug("self.selectedIndex %d", self.selectedIndex)
except exceptions.ChoiceProblem:
return
fileItem = self.fileItems[self.selectedIndex]
logger.debug("Filepath %s", fileItem.filepath)
self.dlgCtrls.txtPrefix.setText(fileItem.prefix)
self.dlgCtrls.chkUseSegnum.setState(fileItem.use_segnum)
logger.debug(util.funcName('end'))
def updateFile(self, selectNewItem):
logger.debug(util.funcName('begin'))
if not 0 <= self.selectedIndex < len(self.fileItems):
if selectNewItem:
self.msgbox.displayExc(self.fileItems.noItemSelected())
else:
logger.debug(util.funcName('return'))
return
newItem = fileitemlist.LingExFileItem(self.userVars)
newItem.filepath = self.fileItems[self.selectedIndex].filepath
newItem.setPrefixNoSpaces(self.dlgCtrls.txtPrefix.getText())
newItem.use_segnum = bool(self.dlgCtrls.chkUseSegnum.getState())
oldItem = self.fileItems[self.selectedIndex]
if oldItem:
if (newItem.filepath == oldItem.filepath
and newItem.prefix == oldItem.prefix
and newItem.use_segnum == oldItem.use_segnum):
logger.debug(
util.funcName('return',
args="%s same as %s" % (newItem, oldItem)))
return
logger.debug("%s not same as %s", newItem, oldItem)
try:
self.fileItems.updateItem(self.selectedIndex, newItem)
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
return
if selectNewItem:
self.refreshListAndSelectItem(newItem)
else:
self.refreshList()
logger.debug(util.funcName('end'))
def refreshList(self):
dutil.fill_list_ctrl(self.dlgCtrls.listboxFiles,
self.fileItems.getItemTextList())
def refreshListAndSelectItem(self, selItem):
logger.debug(util.funcName('begin'))
dutil.fill_list_ctrl(self.dlgCtrls.listboxFiles,
self.fileItems.getItemTextList(), str(selItem))
try:
self.selectedIndex = dutil.get_selected_index(
self.dlgCtrls.listboxFiles)
logger.debug("self.selectedIndex %d", self.selectedIndex)
self.viewFile(False)
except exceptions.ChoiceProblem:
return
logger.debug(util.funcName('end'))
def addFile(self):
logger.debug(util.funcName('begin'))
filepath = filepicker.showFilePicker(self.unoObjs)
if filepath != "":
newItem = fileitemlist.LingExFileItem(self.userVars)
newItem.filepath = filepath
try:
logger.debug("Adding item '%s'", str(newItem))
self.fileItems.addItem(newItem)
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
return
self.refreshListAndSelectItem(newItem)
logger.debug(util.funcName('end'))
def removeFile(self):
logger.debug(util.funcName('begin'))
try:
self.fileItems.deleteItem(self.selectedIndex)
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
return
self.refreshList()
## Select the next item
if self.dlgCtrls.listboxFiles.getItemCount() > 0:
dutil.select_index(self.dlgCtrls.listboxFiles, self.selectedIndex)
self.viewFile(False)
else:
## The list is empty. Clear the text field.
self.dlgCtrls.txtPrefix.setText("")
self.dlgCtrls.chkUseSegnum.setState(False)
self.selectedIndex = -1
logger.debug("FileRemove end")
def storeAndClose(self):
"""Get settings from form and update user variables and
document settings.
"""
logger.debug(util.funcName('begin'))
self.updateFile(False)
self.fileItems.storeUserVars()
for ctrl, varname in self.dlgCtrls.CHECKBOX_VAR_LIST:
state = ctrl.getState() # 0 not checked, 1 checked
self.userVars.store(varname, str(state))
state = self.dlgCtrls.optTables.getState()
varname = "Method"
if state == 1: # selected
self.userVars.store(varname, 'tables')
else:
self.userVars.store(varname, 'frames')
varname = "SFM_Baseline"
if self.userVars.isEmpty(varname):
self.userVars.store(varname, "WordLine1")
## Modify document settings
try:
grammarStyles = GrammarStyles(self.unoObjs, self.userVars)
grammarStyles.createStyles()
uservars.GrammarTags(self.userVars).loadUserVars()
ctrlText = self.dlgCtrls.txtNumColWidth.getText()
grammarStyles.resizeNumberingCol(ctrlText,
self.dlgCtrls.origNumColWidth)
except (exceptions.ChoiceProblem, exceptions.StyleError) as exc:
self.msgbox.displayExc(exc)
return
self.dlgClose()
class DlgWordList:
"""Main class for this dialog."""
def __init__(self, unoObjs, newUserVarPrefix=None):
self.unoObjs = unoObjs
self.msgbox = MessageBox(unoObjs) # calls theLocale.loadUnoObjs()
userVarPrefix = uservars.Prefix.WORD_LIST
if newUserVarPrefix:
userVarPrefix = newUserVarPrefix
uservars.SettingsDocPreparer(userVarPrefix, unoObjs).prepare()
self.userVars = uservars.UserVars(
userVarPrefix, unoObjs.document, logger)
self.fileItems = FileItemList(WordListFileItem, self.userVars)
self.punctToRemove = ""
self.normForm = DEFAULT_NORM_FORM
self.columnOrder = ColumnOrder(self.userVars)
self.app = WordList(
unoObjs, self.fileItems, self.columnOrder, self.userVars)
self.generateOnClose = False
self.disposeWhenFinished = True
self.ok = False
self.dlgCtrls = None
self.evtHandler = None
self.dlgClose = None
self.dlgDispose = None
def dontDisposeWhenFinished(self):
"""If you do this, then call .dlgDispose() when finished."""
self.disposeWhenFinished = False
def getResult(self):
"""The dialog result for calling code."""
return self.ok
def showDlg(self):
logger.debug(util.funcName(obj=self))
dlg = dutil.createDialog(self.unoObjs, _dlgdef)
if not dlg:
return
ctrl_getter = dutil.ControlGetter(dlg)
self.evtHandler = DlgEventHandler(self, self.app)
self.dlgCtrls = DlgControls(
self.unoObjs, ctrl_getter, self.evtHandler)
self.evtHandler.setCtrls(self.dlgCtrls)
self.columnOrder.loadUserVars()
self.dlgCtrls.loadValues(
self.userVars, self.fileItems, self.disposeWhenFinished)
self.set_listboxColOrder_values()
self.dlgClose = dlg.endExecute
self.dlgDispose = dlg.dispose
dlg.execute()
if self.generateOnClose:
self.app.generateList(self.punctToRemove, self.normForm)
if self.disposeWhenFinished:
dlg.dispose()
def fileAdd(self):
logger.debug(util.funcName('begin'))
newItem = WordListFileItem(self.userVars)
dlgFile = DlgWordListFile(newItem, self.unoObjs, self.userVars)
dlgFile.showDlg()
ok = dlgFile.getResult()
dlgFile.dlgDispose()
if ok:
logger.debug("Adding item text %s", newItem)
try:
self.fileItems.addItem(newItem)
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
return
self.fileItems.storeUserVars()
logger.debug("Successfully added.")
dutil.fill_list_ctrl(
self.dlgCtrls.listboxFiles, self.fileItems.getItemTextList(),
str(newItem))
if self.disposeWhenFinished:
self.dlgCtrls.btnMakeList.Label = theLocale.getText(
"Make List")
logger.debug("FileAdd end")
def fileChange(self):
logger.debug(util.funcName('begin'))
try:
itemPos = dutil.get_selected_index(
self.dlgCtrls.listboxFiles, "a file")
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
return
fileItem = self.fileItems[itemPos]
logger.debug("Copying item.")
newItem = fileItem.getDeepCopy()
dlgFile = DlgWordListFile(newItem, self.unoObjs, self.userVars)
dlgFile.showDlg()
ok = dlgFile.getResult()
dlgFile.dlgDispose()
if ok:
logger.debug("Updating item.")
try:
self.fileItems.updateItem(itemPos, newItem)
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
self.fileItems.storeUserVars()
logger.debug("Successfully updated.")
logger.debug("Removing item at %d", itemPos)
self.dlgCtrls.listboxFiles.removeItems(itemPos, 1)
add_at_index = itemPos
logger.debug("Adding item at %d", add_at_index)
self.dlgCtrls.listboxFiles.addItem(
str(newItem), add_at_index)
self.dlgCtrls.listboxFiles.selectItemPos(add_at_index, True)
logger.debug("FileUpdate end")
def fileRemove(self):
logger.debug(util.funcName('begin'))
try:
itemPos = dutil.get_selected_index(
self.dlgCtrls.listboxFiles, "a file")
self.fileItems.deleteItem(itemPos)
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
return
self.fileItems.storeUserVars()
self.dlgCtrls.listboxFiles.removeItems(itemPos, 1)
if len(self.fileItems) == 0 and self.disposeWhenFinished:
self.dlgCtrls.btnMakeList.Label = theLocale.getText(
"Make Empty List")
# Select the next item
dutil.select_index(self.dlgCtrls.listboxFiles, itemPos)
logger.debug(util.funcName('end'))
def moveUp(self):
logger.debug(util.funcName('begin'))
try:
itemPos = dutil.get_selected_index(self.dlgCtrls.listboxColOrder)
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
return
changed = self.columnOrder.moveUp(itemPos)
if changed:
self.set_listboxColOrder_values(itemPos - 1)
def moveDown(self):
logger.debug(util.funcName('begin'))
try:
itemPos = dutil.get_selected_index(self.dlgCtrls.listboxColOrder)
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
return
changed = self.columnOrder.moveDown(itemPos)
if changed:
self.set_listboxColOrder_values(itemPos + 1)
def makeList(self):
logger.debug(util.funcName('begin'))
if len(self.fileItems) == 0 and not self.disposeWhenFinished:
self.msgbox.display("Please add a file to get words.")
return
self.storeUserVars()
if self.disposeWhenFinished:
self.generateOnClose = True
else:
self.ok = True
self.dlgClose()
def set_listboxColOrder_values(self, selItemPos=-1):
listbox = self.dlgCtrls.listboxColOrder
selectedValue = ""
if selItemPos >= 0 and selItemPos < listbox.getItemCount():
selectedValue = self.columnOrder.getTitle(selItemPos)
dutil.fill_list_ctrl(
listbox, self.columnOrder.getTitles(), selectedValue)
def storeUserVars(self):
self.punctToRemove = self.dlgCtrls.txtRemovePunct.getText()
self.userVars.store("Punctuation", self.punctToRemove)
self.normForm = self.userVars.get('NormForm')
self.columnOrder.storeUserVars()
for fileItem in self.fileItems:
if fileItem.filetype in PhonReader.supportedNames():
uservars.InterlinTags(self.userVars).loadUserVars()
break
for fileItem in self.fileItems:
if fileItem.filetype in InterlinReader.supportedNames():
uservars.PhonologyTags(self.userVars).loadUserVars()
break
class DlgAbbreviations:
"""Main class for this dialog."""
def __init__(self, unoObjs):
self.unoObjs = unoObjs
self.userVars = UserVars(Prefix.ABBREVIATIONS, unoObjs.document,
logger)
self.msgbox = MessageBox(unoObjs)
self.abbrevList = abbreviations.AbbrevList(self.unoObjs, self.userVars)
self.selectedIndex = -1 # position in abbrevList and listboxAbbrevs
self.selectedAbbrev = None
self.dlgCtrls = None
self.evtHandler = None
self.dlgClose = None
def showDlg(self):
logger.debug(util.funcName(obj=self))
dlg = dutil.createDialog(self.unoObjs, _dlgdef)
if not dlg:
return
ctrl_getter = dutil.ControlGetter(dlg)
self.dlgClose = dlg.endExecute
self.evtHandler = DlgEventHandler(self)
self.dlgCtrls = DlgControls(self.unoObjs, ctrl_getter, self.evtHandler)
logger.debug("Got controls.")
self.dlgCtrls.loadValues(self.userVars, self.abbrevList)
self.viewAbbrev(False)
## Display the dialog and then close it
dlg.execute()
self.storeResults()
dlg.dispose()
def viewAbbrev(self, checkForUpdates):
"""
Fill the form with values of the selected abbreviation.
:param checkForUpdates: set to true to update current item if needed
"""
logger.debug(util.funcName('begin'))
if checkForUpdates:
newSelectedItem = self.dlgCtrls.listboxAbbrevs.getSelectedItem()
logger.debug("newSelectedItem '%s'", newSelectedItem)
self.updateAbbrev(False)
if newSelectedItem:
# Select the new item again,
# since it may have been deselected while refreshing the list.
self.dlgCtrls.listboxAbbrevs.selectItem(newSelectedItem, True)
try:
self.selectedIndex = dutil.get_selected_index(
self.dlgCtrls.listboxAbbrevs)
logger.debug("self.selectedIndex %d", self.selectedIndex)
except exceptions.ChoiceProblem:
return
abbr = self.abbrevList[self.selectedIndex]
logger.debug("Abbrev %s", abbr.abbrevText)
self.dlgCtrls.txtAbbrev.setText(abbr.abbrevText)
self.dlgCtrls.txtFullName.setText(abbr.fullName)
if abbr.forceOutput:
self.dlgCtrls.chkForceOutput.setState(True)
else:
self.dlgCtrls.chkForceOutput.setState(False)
self.dlgCtrls.txtOccurrences.setText(abbr.occurrences)
logger.debug(util.funcName('end'))
def updateAbbrev(self, selectNewItem):
"""
Update abbrev attributes from dialog fields if changed.
:param selectNewItem: set to True to select item when refreshing list
"""
logger.debug(util.funcName('begin'))
if not 0 <= self.selectedIndex < len(self.abbrevList):
if selectNewItem:
self.msgbox.displayExc(self.abbrevList.noItemSelected())
return
newAbbrev = abbreviations.Abbrev()
newAbbrev.abbrevText = self.dlgCtrls.txtAbbrev.getText()
if not newAbbrev.abbrevText:
return
newAbbrev.fullName = self.dlgCtrls.txtFullName.getText()
if self.dlgCtrls.chkForceOutput.getState() == 1: # checked
newAbbrev.forceOutput = True
oldAbbrev = self.abbrevList[self.selectedIndex]
if oldAbbrev:
if newAbbrev.sameAs(oldAbbrev):
return
logger.debug("%r not sameAs %r", newAbbrev, oldAbbrev)
if newAbbrev.abbrevText == oldAbbrev.abbrevText:
newAbbrev.occurrences = oldAbbrev.occurrences
try:
self.abbrevList.updateItem(self.selectedIndex, newAbbrev)
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
return
if selectNewItem:
self.refreshListAndSelectItem(newAbbrev)
else:
self.refreshList()
logger.debug(util.funcName('end'))
def refreshList(self):
dutil.fill_list_ctrl(self.dlgCtrls.listboxAbbrevs,
self.abbrevList.getItemTextList())
def refreshListAndSelectItem(self, selItem):
logger.debug(util.funcName('begin'))
dutil.fill_list_ctrl(self.dlgCtrls.listboxAbbrevs,
self.abbrevList.getItemTextList(), str(selItem))
try:
self.selectedIndex = dutil.get_selected_index(
self.dlgCtrls.listboxAbbrevs)
logger.debug("self.selectedIndex %d", self.selectedIndex)
self.viewAbbrev(False)
except exceptions.ChoiceProblem:
return
logger.debug(util.funcName('end'))
def addAbbrev(self):
logger.debug(util.funcName('begin'))
newAbbrev = abbreviations.Abbrev()
newAbbrev.abbrevText = "---"
newAbbrev.fullName = ""
self.abbrevList.addItem(newAbbrev, allowDuplicates=True)
self.refreshListAndSelectItem(newAbbrev)
logger.debug(util.funcName('end'))
def deleteAbbrev(self):
logger.debug(util.funcName('begin'))
try:
self.abbrevList.deleteItem(self.selectedIndex)
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
return
self.refreshList()
## Select the next item
if self.dlgCtrls.listboxAbbrevs.getItemCount() > 0:
dutil.select_index(self.dlgCtrls.listboxAbbrevs,
self.selectedIndex)
self.viewAbbrev(False)
else:
## The list is empty. Clear the fields.
logger.debug("Clearing fields.")
self.dlgCtrls.txtAbbrev.setText("")
self.dlgCtrls.txtFullName.setText("")
self.dlgCtrls.chkForceOutput.setState(False)
self.dlgCtrls.txtOccurrences.setText(0)
self.selectedIndex = -1
logger.debug(util.funcName('end'))
def changeAllCaps(self):
logger.debug(util.funcName('begin'))
self.abbrevList.changeAllCaps()
self.refreshList()
dutil.select_index(self.dlgCtrls.listboxAbbrevs, self.selectedIndex)
self.viewAbbrev(False)
logger.debug(util.funcName('end'))
def rescan(self):
logger.debug(util.funcName('begin'))
abbrevSearch = search.AbbrevSearch(self.unoObjs)
abbrevSearch.findOccurrences(self.abbrevList)
self.refreshList()
dutil.select_index(self.dlgCtrls.listboxAbbrevs, self.selectedIndex)
self.viewAbbrev(False)
logger.debug(util.funcName('end'))
def insertList(self):
logger.debug(util.funcName('begin'))
## Rescan and prepare for output
abbrevSearch = search.AbbrevSearch(self.unoObjs)
abbrevSearch.findOccurrences(self.abbrevList)
self.refreshList()
self.abbrevList.storeUserVars()
abbrevStyles = styles.AbbrevStyles(self.unoObjs, self.userVars)
abbrevStyles.createStyles()
## Output the list and close
writerOutput = outputmanager.AbbrevManager(self.unoObjs, abbrevStyles)
try:
writerOutput.outputList(self.abbrevList)
except exceptions.MessageError as exc:
self.msgbox.displayExc(exc)
self.dlgClose()
logger.debug(util.funcName('end'))
def findNext(self):
logger.debug(util.funcName('begin'))
## Get search form results
displayName = self.dlgCtrls.cmbxSearchParaStyle.getText()
if not displayName:
self.msgbox.display("Please select a paragraph style.")
return
searchConfig = search.AbbrevSearchSettings()
searchConfig.searchParaStyle = displayName
self.userVars.store("SearchParaStyle", displayName)
searchConfig.searchAffix = "any"
if self.dlgCtrls.optSearchSuffix.getState() == 1: # checked
searchConfig.searchAffix = "suffix"
elif self.dlgCtrls.optSearchPrefix.getState() == 1: # checked
searchConfig.searchAffix = "prefix"
self.userVars.store("SearchAffix", searchConfig.searchAffix)
try:
searchConfig.maxSearchLength = int(
self.dlgCtrls.txtMaxSearchLength.getText())
except ValueError:
self.msgbox.display("Please enter a number for max length.")
return
self.userVars.store("MaxSearchLength", searchConfig.maxSearchLength)
searchConfig.searchUpperCase = False
chkValue = self.dlgCtrls.chkSearchUpperCase.getState()
if chkValue == 1:
searchConfig.searchUpperCase = True
self.userVars.store("SearchUpperCase", str(chkValue))
searchConfig.startFromBeginning = False
if self.dlgCtrls.chkStartFromBeginning.getState() == 1:
searchConfig.startFromBeginning = True
self.dlgCtrls.chkStartFromBeginning.setState(False)
searchConfig.searchDelimiters = self.userVars.get("SearchDelimiters")
## Search
abbrevSearch = search.AbbrevSearch(self.unoObjs)
while True:
possibleAbbrevs = abbrevSearch.findNext(
searchConfig, self.abbrevList.getUniqueList())
if len(possibleAbbrevs) == 0:
self.msgbox.display("No more possible abbreviations found.")
return
for possibleAbbrevText in possibleAbbrevs:
if possibleAbbrevText.strip() == "":
continue
result = self.msgbox.displayYesNoCancel(
"Add '%s' as a new abbreviation?", possibleAbbrevText)
if result == "yes":
logger.debug("Adding abbreviation from search.")
newAbbrev = abbreviations.Abbrev()
newAbbrev.abbrevText = possibleAbbrevText
newAbbrev.occurrences = 1
try:
self.abbrevList.addItem(newAbbrev)
self.refreshListAndSelectItem(newAbbrev)
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
elif result == "cancel":
return
elif result == "no":
## continue
pass
logger.debug(util.funcName('end'))
def storeResults(self):
logger.debug(util.funcName('begin'))
self.updateAbbrev(False)
self.abbrevList.storeUserVars()
logger.debug(util.funcName('end'))
class DlgWordListFile:
"""Main class for this dialog."""
def __init__(self, fileItem, unoObjs, userVars):
"""fileItem is expected to be of type WordListFileItem.
It will be modified by reference,
so the new value can be used when this dialog is finished.
"""
self.fileItem = fileItem
self.filetype = fileItem.filetype
self.thingsToGrab = [
copy.copy(whatToGrab) for whatToGrab in fileItem.thingsToGrab
]
logger.debug("len(self.thingsToGrab) = %d", len(self.thingsToGrab))
self.unoObjs = unoObjs
self.userVars = userVars
self.msgbox = MessageBox(unoObjs) # calls theLocale.loadUnoObjs()
self.ok = False
self.titles = None
self.paraStyleNames = []
self.charStyleNames = []
self.fileTypeDict = dict()
self.fileTypeNames = []
self.dlgCtrls = None
self.evtHandler = None
self.dlgClose = None
self.dlgDispose = None
def getResult(self):
return self.ok
def showDlg(self):
logger.debug(util.funcName('begin', obj=self))
dlg = dutil.createDialog(self.unoObjs, _dlgdef)
if not dlg:
return
ctrl_getter = dutil.ControlGetter(dlg)
self.evtHandler = DlgEventHandler(self)
self.dlgCtrls = DlgControls(self.unoObjs, ctrl_getter, self.evtHandler)
self.evtHandler.setCtrls(self.dlgCtrls)
styleNames = styles.getListOfStyles('ParagraphStyles', self.unoObjs)
self.paraStyleNames = dict(styleNames)
paraStyleDispNames = tuple([dispName for dispName, name in styleNames])
styleNames = styles.getListOfStyles('CharacterStyles', self.unoObjs)
self.charStyleNames = dict(styleNames)
charStyleDispNames = tuple([dispName for dispName, name in styleNames])
self.dlgCtrls.loadValues(paraStyleDispNames,
charStyleDispNames, self.fileItem,
self.getTypesTuple(), self.fileTypeDict,
self.fillFieldList)
self.dlgCtrls.enableDisable(self.filetype)
self.dlgClose = dlg.endExecute
self.dlgDispose = dlg.dispose
logger.debug(util.funcName('end', obj=self))
dlg.execute()
def fillFieldList(self):
"""Fills listWhatToGrab based on self.filetype."""
count = self.dlgCtrls.listWhatToGrab.getItemCount()
self.dlgCtrls.listWhatToGrab.removeItems(0, count)
self.titles = [("", "")]
if self.filetype in PhonReader.supportedNames():
self.titles.extend(lingex_structs.LingPhonExample.GRAB_FIELDS)
elif self.filetype in InterlinReader.supportedNames():
self.titles.extend(lingex_structs.LingGramExample.GRAB_FIELDS)
elif self.filetype in DocReader.supportedNames():
self.titles.append((WhatToGrab.WHOLE_DOC, "Whole Document"))
elif self.filetype in CalcFileReader.supportedNames():
for char in string.ascii_uppercase:
self.titles.append(
(char, "%s %s" % (theLocale.getText("Column"), char)))
if len(self.titles) > 1:
stringList = [
theLocale.getText(display)
for dummy_key, display in self.titles
]
self.dlgCtrls.listWhatToGrab.addItems(tuple(stringList), 0)
def useCurrent(self):
logger.debug(util.funcName('begin'))
url = self.unoObjs.document.getURL()
if not url:
self.msgbox.display("Please save the current document first.")
return
syspath = uno.fileUrlToSystemPath(url)
self.dlgCtrls.fileControl.setText(syspath)
dummy, title = DocReader.SUPPORTED_FORMATS[0]
self.dlgCtrls.listboxFileType.selectItem(title, False)
self.dlgCtrls.listboxFileType.selectItem(title, True)
def selectWritingSys(self):
logger.debug(util.funcName('begin'))
filepath = self.dlgCtrls.fileControl.getText()
defaultCode = self.dlgCtrls.txtWS.getText()
dlgWS = DlgWritingSystem(defaultCode, self.unoObjs)
dlgWS.readFile(filepath)
dlgWS.showDlg()
writingSystem = dlgWS.getResult()
dlgWS.call_dispose()
self.dlgCtrls.txtWS.setText(writingSystem.internalCode)
def addItem(self):
"""Handle button press. Add whatever form field was changed."""
logger.debug(
util.funcName('begin',
args="%d control(s) changed." %
len(self.dlgCtrls.ctrlsChanged)))
something_to_add = False
for ctrlName, ctrl in self.dlgCtrls.ctrlsChanged.items():
logger.debug(ctrlName)
if ctrl == self.dlgCtrls.listWhatToGrab:
newObj = self.fieldItemToAdd(ctrl.getSelectedItemPos())
else:
newObj = self.formItemToAdd(ctrlName, ctrl)
if (newObj.grabType != WhatToGrab.UNSPECIFIED
and newObj.whichOne.strip() != ""):
self.addWhatToGrab(newObj)
something_to_add = True
if not something_to_add:
self.msgbox.display("Please select or enter something to find.")
self.dlgCtrls.clearWhatToFind()
logger.debug(util.funcName('end'))
def fieldItemToAdd(self, itemPos):
"""Create a field item to be added."""
newObj = WhatToGrab(self.userVars)
if itemPos >= 0:
key, dummy_display = self.titles[itemPos]
newObj.whichOne = key
if self.filetype in CalcFileReader.supportedNames():
newObj.grabType = WhatToGrab.COLUMN
elif self.filetype in DocReader.supportedNames():
newObj.grabType = WhatToGrab.PART
else:
newObj.grabType = WhatToGrab.FIELD
logger.debug(
util.funcName('end', args=(newObj.whichOne, newObj.grabType)))
return newObj
def formItemToAdd(self, ctrlName, ctrl):
"""Create a form item to be added."""
newObj = WhatToGrab(self.userVars)
newObj.whichOne = ctrl.getText()
if ctrlName == self.dlgCtrls.comboParaStyle.getModel().Name:
# use display name to search
newObj.grabType = WhatToGrab.PARASTYLE
displayName = ctrl.getText()
if displayName in self.paraStyleNames:
newObj.whichOne = self.paraStyleNames[displayName]
elif ctrlName == self.dlgCtrls.comboCharStyle.getModel().Name:
newObj.grabType = WhatToGrab.CHARSTYLE
displayName = ctrl.getText()
if displayName in self.charStyleNames:
newObj.whichOne = self.charStyleNames[displayName]
elif ctrlName == self.dlgCtrls.comboFont.getModel().Name:
newObj.grabType = WhatToGrab.FONT
newObj.fontType = 'Western'
if self.dlgCtrls.optFontTypeComplex.getState() == 1:
newObj.fontType = 'Complex'
elif self.dlgCtrls.optFontTypeAsian.getState() == 1:
newObj.fontType = 'Asian'
elif ctrlName == self.dlgCtrls.txtSFM.getModel().Name:
newObj.grabType = WhatToGrab.SFM
logger.debug(
util.funcName('end', args=(newObj.whichOne, newObj.grabType)))
return newObj
def addWhatToGrab(self, newObj):
"""Add newObj to the list."""
logger.debug(
util.funcName('begin',
args="len(self.thingsToGrab) = %d" %
len(self.thingsToGrab)))
newObj.whichOne = newObj.whichOne.strip()
for whatToGrab in self.thingsToGrab:
if str(whatToGrab) == str(newObj):
self.msgbox.display("%s is already in the list.",
str(whatToGrab))
return
self.thingsToGrab.append(newObj)
self.thingsToGrab.sort(key=str)
stringList = [str(df) for df in self.thingsToGrab]
dutil.fill_list_ctrl(self.dlgCtrls.listboxFields, stringList,
str(newObj))
logger.debug(
util.funcName('end',
args="len(self.thingsToGrab) = %d" %
len(self.thingsToGrab)))
def removeItem(self):
"""Handle button press."""
logger.debug(util.funcName('begin'))
try:
itemPos = dutil.get_selected_index(self.dlgCtrls.listboxFields)
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
return
del self.thingsToGrab[itemPos]
self.dlgCtrls.listboxFields.removeItems(itemPos, 1)
# Select the next item
dutil.select_index(self.dlgCtrls.listboxFields, itemPos)
logger.debug(
util.funcName('end',
args="len(self.thingsToGrab) = %d" %
len(self.thingsToGrab)))
def doOk(self):
"""Handle button press."""
logger.debug(
util.funcName('begin',
args="len(self.thingsToGrab) = %d" %
len(self.thingsToGrab)))
if (len(self.thingsToGrab) == 0
and self.filetype not in ['spellingStatus']):
ok = self.msgbox.displayOkCancel(
"You did not specify anything to find. Continue anyway?")
if not ok:
return
for whatToGrab in self.thingsToGrab:
if whatToGrab.whichOne == WhatToGrab.WHOLE_DOC:
if len(self.thingsToGrab) > 1:
self.msgbox.display(
"'Whole Document' must be the only thing to find.")
return
self.fileItem.filepath = self.dlgCtrls.fileControl.getText()
self.fileItem.filetype = self.filetype
self.fileItem.writingSystem = self.dlgCtrls.txtWS.getText()
self.fileItem.thingsToGrab = self.thingsToGrab
logger.debug("len(self.thingsToGrab) = %d", len(self.thingsToGrab))
self.fileItem.includeMisspellings = (
self.dlgCtrls.checkboxMiss.getState() == 1)
self.fileItem.skipFirstRow = (
self.dlgCtrls.checkboxSkipRow.getState() == 1)
self.fileItem.splitByWhitespace = (
self.dlgCtrls.checkboxSplit.getState() == 1)
self.ok = True
self.dlgClose()
def getTypesTuple(self):
"""Get file types that can be read for a word list.
Returns a tuple suitable for filling a list box.
Note: This method cannot be named getTypes(), apparently because that
name is used in an unohelper.Base interface, XTypeProvider.
Update 02-Jul-2015: This is probably only the case if this class
inherits from unohelper.Base, which it no longer does.
"""
fileTypes = (DocReader.SUPPORTED_FORMATS +
CalcFileReader.SUPPORTED_FORMATS +
WordsReader.SUPPORTED_FORMATS +
PhonReader.SUPPORTED_FORMATS +
InterlinReader.SUPPORTED_FORMATS +
SFM_Reader.SUPPORTED_FORMATS)
self.fileTypeDict = dict(fileTypes)
self.fileTypeNames, titles = zip(*fileTypes)
return titles
class DlgDataConversion:
"""Main class for this dialog."""
def __init__(self, drawingUnoObjs):
self.unoObjs = drawingUnoObjs
finder = uservars.SettingsDocFinder(
uservars.Prefix.DATA_CONV_DRAW, self.unoObjs)
writerUnoObjs = finder.getWriterDoc()
self.userVars = uservars.UserVars(
uservars.Prefix.DATA_CONV_DRAW, writerUnoObjs.document, logger)
self.msgbox = MessageBox(self.unoObjs)
self.styleFonts = styles.StyleFonts(self.unoObjs)
self.app = DataConversion(self.unoObjs, self.userVars, self.styleFonts)
self.dlgCtrls = None
self.evtHandler = None
self.config = None
self.converter = None
self.convertOnClose = False
self.dlgClose = None
def showDlg(self):
logger.debug(util.funcName(obj=self))
dlg = dutil.createDialog(self.unoObjs, _dlgdef)
if not dlg:
return
ctrl_getter = dutil.ControlGetter(dlg)
self.evtHandler = DlgEventHandler(self)
self.dlgCtrls = None
self.dlgCtrls = DlgControls(
self.unoObjs, ctrl_getter, self.evtHandler)
self.evtHandler.setCtrls(self.dlgCtrls)
logger.debug("Getting styles...")
self.dlgCtrls.loadValues(self.userVars)
self.dlgCtrls.enableDisable(self)
## Display the dialog
self.dlgClose = dlg.endExecute
dlg.execute()
if self.convertOnClose:
self.app.doConversions_draw()
dlg.dispose()
def selectTargetFont(self):
"""Selects the font from user variables."""
logger.debug(util.funcName('begin'))
listCtrl = self.dlgCtrls.listTargetFont # shorthand variable
listValues = listCtrl.Items
fontName = self.userVars.get('TargetFontName')
fontSize = FontSize()
fontSize.loadUserVar(self.userVars, 'TargetFontSize')
if fontName and fontName in listValues:
listCtrl.selectItem(fontName, True)
else:
listCtrl.selectItemPos(0, True)
fontSize.changeCtrlVal(self.dlgCtrls.txtFontSize)
def selectConverter(self):
logger.debug(util.funcName('begin'))
logger.debug("Selecting a converter...")
converter = self.app.selectConverter()
self.dlgCtrls.txtConverterName.setText(converter.convName)
self.dlgCtrls.chkDirectionReverse.setState(not converter.forward)
def noConverter(self):
logger.debug(util.funcName('begin'))
logger.debug("Clearing converter...")
self.dlgCtrls.txtConverterName.setText("<No converter>")
def closeAndConvert(self):
logger.debug(util.funcName('begin'))
logger.debug("Closing and Converting...")
self.getFormResults()
try:
self.app.setAndVerifyConverter(self.converter)
self.app.setAndVerifyConfig(self.config)
self.convertOnClose = True
self.dlgClose()
except (exceptions.ChoiceProblem, exceptions.StyleError) as exc:
self.msgbox.displayExc(exc)
def getFormResults(self):
"""Reads form fields and sets self.config and self.converter.
In setAndVerifyConfig() in app layer, the settings will be checked for
inconsistencies.
"""
logger.debug(util.funcName('begin'))
## Converter
self.converter = ConverterSettings(self.userVars)
self.converter.loadUserVars() # for normForm
self.converter.convName = self.dlgCtrls.txtConverterName.getText()
self.converter.forward = (
self.dlgCtrls.chkDirectionReverse.getState() == 0)
self.converter.storeUserVars()
## Radio buttons and the corresponding combo box selection
self.config = ConversionSettings()
searchConfig = self.config.searchConfig # shorthand name
self.config.whichScope = dutil.whichSelected(
self.dlgCtrls.radiosWhichScope)
self.userVars.store('WhichScope', self.config.whichScope)
if self.config.whichScope == 'Font':
searchConfig.fontName = self.dlgCtrls.comboScopeFont.getText()
searchConfig.fontType = dutil.whichSelected(
self.dlgCtrls.radiosScopeFont)
self.userVars.store('ScopeFontType', searchConfig.fontType)
searchConfig.load_userVars(self.userVars)
self.config.whichTarget = dutil.whichSelected(
self.dlgCtrls.radiosWhichTarget)
self.userVars.store('WhichTarget', self.config.whichTarget)
## Target font
targetFontName = self.dlgCtrls.listTargetFont.getSelectedItem()
if targetFontName == "(None)":
targetFontName = None
targetFontSize = FontSize()
targetFontSize.loadCtrl(self.dlgCtrls.txtFontSize)
if self.config.whichTarget == 'Font':
self.userVars.store('TargetFontName', targetFontName)
self.userVars.store('TargetFontSize', targetFontSize.getString())
targetFontType = dutil.whichSelected(
self.dlgCtrls.radiosTargetFont)
self.userVars.store('TargetFontType', targetFontType)
self.config.targetFont = styles.FontDefStruct(
targetFontName, targetFontType, targetFontSize)
self.config.askEach = (self.dlgCtrls.chkVerify.getState() == 1)
## Save selections for next time
for combo in self.dlgCtrls.combos:
self.userVars.store(combo.varname, combo.ctrl.getText())
self.userVars.store('AskEachChange',
str(self.dlgCtrls.chkVerify.getState()))
logger.debug(util.funcName('end'))
class DlgApplyConverter:
"""Main class for this dialog."""
def __init__(self, calcUnoObjs):
self.unoObjs = calcUnoObjs
self.msgbox = MessageBox(self.unoObjs)
finder = uservars.SettingsDocFinder(uservars.Prefix.WORD_LIST,
self.unoObjs)
writerUnoObjs = finder.getWriterDoc()
self.userVars = uservars.UserVars(uservars.Prefix.WORD_LIST,
writerUnoObjs.document, logger)
self.app = DataConversion(self.unoObjs, self.userVars, styleFonts=None)
self.sourceCol = ""
self.targetCol = ""
self.skipFirstRow = True
self.convertOnClose = False
self.dlgCtrls = None
self.evtHandler = None
self.dlgClose = None
def showDlg(self):
logger.debug(util.funcName(obj=self))
dlg = dutil.createDialog(self.unoObjs, _dlgdef)
if not dlg:
return
ctrl_getter = dutil.ControlGetter(dlg)
self.evtHandler = DlgEventHandler(self)
self.dlgCtrls = DlgControls(self.unoObjs, ctrl_getter, self.evtHandler)
self.dlgCtrls.loadValues(self.userVars)
## Display the dialog
self.dlgClose = dlg.endExecute
dlg.execute()
if self.convertOnClose:
self.app.doConversions_calc(self.sourceCol, self.targetCol,
self.skipFirstRow)
dlg.dispose()
def selectConverter(self):
logger.debug(util.funcName('begin'))
converter = self.app.selectConverter()
self.dlgCtrls.txtConverterName.setText(converter.convName)
self.dlgCtrls.chkDirectionReverse.setState(not converter.forward)
logger.debug(util.funcName('end'))
def closeAndConvert(self):
logger.debug(util.funcName('begin'))
converter = self.getFormResults()
try:
self.app.setAndVerifyConverter(converter)
self.convertOnClose = True
self.dlgClose()
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
logger.debug(util.funcName('end'))
def getFormResults(self):
"""
Reads form fields and stores user vars.
returns: converter settings
"""
logger.debug(util.funcName('begin'))
converter = ConverterSettings(self.userVars)
converter.loadUserVars() # for normForm
converter.convName = self.dlgCtrls.txtConverterName.getText()
converter.forward = (self.dlgCtrls.chkDirectionReverse.getState() == 0)
converter.storeUserVars()
self.sourceCol = self.dlgCtrls.txtSourceCol.getText()
self.targetCol = self.dlgCtrls.txtTargetCol.getText()
self.skipFirstRow = bool(self.dlgCtrls.chkSkipRow.getState())
self.userVars.store("ConvSourceColumn", self.sourceCol)
self.userVars.store("ConvTargetColumn", self.targetCol)
self.userVars.store("SkipFirstRow",
str(self.dlgCtrls.chkSkipRow.getState()))
logger.debug(util.funcName('end'))
return converter
class WordList:
def __init__(self, writerUnoObjs, fileItems, columnOrder, userVars):
self.unoObjs = writerUnoObjs
self.fileItems = fileItems # FileItemList of WordListFileItem
self.columnOrder = columnOrder
self.userVars = userVars
self.msgbox = MessageBox(self.unoObjs)
self.words = []
self.progressBar = None
def generateList(self, punctToRemove, normForm, outputToCalc=True):
"""Harvest words from various files.
If outputToCalc is True, then output a word list in Calc.
"""
logger.debug(util.funcName('begin'))
all_words_read = []
self.progressBar = ProgressBar(self.unoObjs, "Reading...")
self.progressBar.show()
self.progressBar.updateBeginning()
progressRange = ProgressRange(
ops=len(self.fileItems), pbar=self.progressBar)
try:
for fileItemIndex, fileItem in enumerate(self.fileItems):
try:
new_words = self._harvestWords(fileItem)
all_words_read.extend(new_words)
logger.debug("Word count: %d", len(all_words_read))
except (exceptions.DataNotFoundError,
exceptions.FileAccessError) as exc:
self.msgbox.displayExc(exc)
progressRange.update(fileItemIndex)
self.progressBar.updateFinishing()
finally:
self.progressBar.close()
self.progressBar = ProgressBar(self.unoObjs, "Sorting...")
self.progressBar.show()
self.progressBar.updateBeginning()
try:
splitByWhitespace = True
if len(self.fileItems) > 0:
splitByWhitespace = self.fileItems[0].splitByWhitespace
self.words = organizeList(
all_words_read, punctToRemove, splitByWhitespace, normForm,
self.progressBar)
self.progressBar.updateFinishing()
finally:
self.progressBar.close()
if self.words or len(self.fileItems) == 0:
if outputToCalc:
self.progressBar = ProgressBar(
self.unoObjs, "Generating List...")
self.progressBar.show()
self.progressBar.updateBeginning()
try:
self._generateCalcList()
self.progressBar.updateFinishing()
finally:
self.progressBar.close()
else:
self.msgbox.display("Found %d words.", len(self.words))
else:
self.msgbox.display("Did not find any words for the list.")
def _harvestWords(self, fileItem):
"""Harvest words from the specified file."""
fileType = fileItem.filetype # short variable name
logger.debug(util.funcName(args=fileType))
words = []
if fileType in WordsReader.supportedNames():
reader = WordsReader(fileItem, self.unoObjs)
words = reader.read()
elif fileType in SFM_Reader.supportedNames():
reader = SFM_Reader(fileItem, self.unoObjs)
words = reader.read()
elif fileType in InterlinReader.supportedNames():
config = fileitemlist.InterlinInputSettings(self.userVars)
config.showMorphLine2 = True
config.separateMorphColumns = True
lingExFileItem = fileitemlist.LingExFileItem(self.userVars)
lingExFileItem.filepath = fileItem.filepath
config.fileList.addItem(lingExFileItem)
reader = InterlinReader(self.unoObjs, self.userVars, config)
words = reader.grabWords(fileItem.thingsToGrab)
elif fileType in PhonReader.supportedNames():
config = lingex_structs.PhonInputSettings(self.userVars)
config.filepath = fileItem.filepath
config.phoneticWS = fileItem.writingSystem
config.isLexemePhonetic = True
phonUserVars = UserVars(
Prefix.PHONOLOGY, self.unoObjs.document, logger)
if phonUserVars.get("FlexLexeme") == 'phonemic':
config.isLexemePhonetic = False
reader = PhonReader(self.unoObjs, self.userVars, config)
words = reader.grabWords(fileItem.thingsToGrab)
elif fileType in DocReader.supportedNames():
settings = TextSearchSettings()
settings.load_userVars(self.userVars)
reader = DocReader(fileItem, self.unoObjs, settings.matchesLimit)
words = reader.read()
elif fileType in CalcFileReader.supportedNames():
reader = CalcFileReader(self.unoObjs)
reader.setFileConfig(fileItem)
words = reader.read()
return words
def _generateCalcList(self):
"""Generate list in calc."""
listOutput = WordlistIO(self.unoObjs, self.columnOrder)
listOutput.outputList(self.words, self.progressBar)
msgbox = listOutput.getMsgbox() # for Calc spreadsheet
## Copy some user vars for the Spelling component.
userVarsSp = UserVars(
Prefix.SPELLING, self.unoObjs.document, logger)
varname = "HasSettings"
userVarsSp.store(varname, self.userVars.get(varname))
columnOrderSp = ColumnOrder(userVarsSp)
columnOrderSp.sortOrder = self.columnOrder.sortOrder
columnOrderSp.storeUserVars()
# Initialize some user vars for Calc dialogs. We do this here
# to reset properly if a new word list is made.
self.userVars.store("ConvSourceColumn",
self.columnOrder.getColLetter('colWord'))
self.userVars.store("ConvTargetColumn",
self.columnOrder.getColLetter('colConv1'))
userVarsSp.store("CurrentRow", "")
msgbox.display("Made list of %d words.", len(self.words))
class DataConversion:
"""Main class for this module."""
def __init__(self, docUnoObjs, userVars, styleFonts=None):
"""unoObjs needs to be for a writer doc if calling
doConversions_writer(),
and for a calc spreadsheet if calling doConversion_calc().
Set styleFonts if calling setAndVerifyConfig(),
which is probably only for the DlgBulkConv dialog.
"""
self.unoObjs = docUnoObjs
self.userVars = userVars
self.changerSettings = TextChangerSettings()
self.changerSettings.load_userVars(userVars)
self.styleFonts = styleFonts
self.msgbox = MessageBox(self.unoObjs)
self.secCall = SEC_wrapper(self.msgbox, userVars)
self.config = None
def selectConverter(self):
"""Returns SEC_wrapper.ConverterSettings object.
Saves normalization value, since it is not configurable in the dialog.
"""
logger.debug(util.funcName('begin'))
try:
self.secCall.pickConverter()
logger.debug("Picked converter.")
except exceptions.FileAccessError as exc:
self.msgbox.displayExc(exc)
logger.debug("Converter name '%s'", self.secCall.config.convName)
self.secCall.config.storeUserVars() # for normalize
return self.secCall.config
def setAndVerifyConverter(self, newConv):
"""Parameter should be of type SEC_wrapper.ConverterSettings.
Call this method before calling one of the doConversion() methods.
"""
## Get the converter if not yet done
if newConv.convName == "":
raise exceptions.ChoiceProblem("Please select a converter.")
if newConv.convName == "<No converter>":
return
if self.secCall.config != newConv:
try:
self.secCall.setConverter(newConv)
logger.debug("Did set converter.")
except exceptions.FileAccessError as exc:
self.msgbox.displayExc(exc)
self.secCall.config.convName = ""
raise exceptions.ChoiceProblem(
"Please select the converter again.")
def setAndVerifyConfig(self, newConfig):
"""Sets self.config from newConfig, which should be type
ConversionSettings.
Throws exceptions.ChoiceProblem if the choices are not acceptable.
"""
logger.debug(util.funcName('begin'))
if not self.styleFonts:
raise exceptions.LogicError("Expected styleFonts to be set.")
if not newConfig.whichScope:
raise exceptions.ChoiceProblem("Please specify a scope.")
if (newConfig.whichScope == 'ParaStyle'
and not newConfig.searchConfig.style):
raise exceptions.ChoiceProblem(
"Please select a scope paragraph style.")
if (newConfig.whichScope == 'CharStyle'
and not newConfig.searchConfig.style):
raise exceptions.ChoiceProblem(
"Please select a scope character style.")
if (newConfig.whichScope == 'Font'
and not newConfig.searchConfig.fontName):
raise exceptions.ChoiceProblem("Please select a scope font.")
if (newConfig.whichScope == 'SFMs'
and not newConfig.searchConfig.SFMs):
raise exceptions.ChoiceProblem("Please specify SFMs.")
if not newConfig.whichTarget:
raise exceptions.ChoiceProblem("Please specify a target.")
if (newConfig.whichTarget == 'ParaStyle'
and not newConfig.targetStyle):
raise exceptions.ChoiceProblem("Please select a target style.")
if (newConfig.whichTarget == 'CharStyle'
and not newConfig.targetStyle):
raise exceptions.ChoiceProblem("Please select a target style.")
if (newConfig.whichTarget == 'FontOnly'
and not newConfig.targetFont.fontName):
raise exceptions.ChoiceProblem("Please select a target font.")
self.config = newConfig
try:
if newConfig.whichTarget == 'ParaStyle':
self.styleFonts.setParaStyleWithFont(newConfig.targetFont,
newConfig.targetStyle)
elif newConfig.whichTarget == 'CharStyle':
self.styleFonts.setCharStyleWithFont(newConfig.targetFont,
newConfig.targetStyle)
except RuntimeException as exc:
logger.exception(exc)
raise exceptions.StyleError("Could not create style '%s'.",
newConfig.targetStyle)
logger.debug(util.funcName('end'))
def doConversions_writer(self):
"""For converting data in a Writer doc."""
logger.debug(util.funcName('begin'))
## Start progress bar
progressBar = ProgressBar(self.unoObjs, "Converting...")
progressBar.show()
progressBar.updateBeginning()
## Find the text ranges
textSearch = TextSearch(self.unoObjs, progressBar)
textSearch.setConfig(self.config.searchConfig)
try:
if self.config.whichScope == 'WholeDoc':
textSearch.scopeWholeDoc()
elif self.config.whichScope == 'Selection':
textSearch.scopeSelection()
elif self.config.whichScope == 'ParaStyle':
textSearch.scopeParaStyle()
elif self.config.whichScope == 'CharStyle':
textSearch.scopeCharStyle()
elif self.config.whichScope == 'Font':
textSearch.scopeFont()
elif self.config.whichScope == 'SFMs':
textSearch.scopeSFMs()
else:
raise exceptions.LogicError("Unexpected value %s",
self.config.whichScope)
except (exceptions.RangeError, exceptions.LogicError) as exc:
self.msgbox.displayExc(exc)
progressBar.close()
return
rangesFound = textSearch.getRanges()
if progressBar.getPercent() < 40:
progressBar.updatePercent(40)
## Do the changes to those ranges
textChanger = TextChanger(self.unoObjs, progressBar,
self.changerSettings)
if self.secCall.config.convName:
textChanger.setConverterCall(self.secCall)
if self.config.whichTarget == "ParaStyle":
textChanger.setStyleToChange("ParaStyleName",
self.config.targetStyle)
elif self.config.whichTarget == "CharStyle":
textChanger.setStyleToChange("CharStyleName",
self.config.targetStyle)
elif self.config.whichTarget == "FontOnly":
textChanger.setFontToChange(self.config.targetFont)
numDataChanges, numStyleChanges = textChanger.doChanges(
rangesFound, self.config.askEach)
progressBar.updateFinishing()
progressBar.close()
## Display results
paragraphsFound = len(rangesFound)
if paragraphsFound == 0:
self.msgbox.display("Did not find scope of change.")
elif numDataChanges == 0:
if numStyleChanges == 0:
self.msgbox.display("No changes.")
else:
plural = "" if numStyleChanges == 1 else "s"
# add "s" if plural
self.msgbox.display(
"No changes, but modified style of %d paragraph%s.",
numStyleChanges, plural)
elif paragraphsFound == 1:
plural = "" if numDataChanges == 1 else "s" # add "s" if plural
self.msgbox.display("Made %d change%s.", numDataChanges, plural)
else:
plural = "" if numDataChanges == 1 else "s" # add "s" if plural
self.msgbox.display("Found %d paragraphs and made %d change%s.",
paragraphsFound, numDataChanges, plural)
def doConversions_calc(self, sourceCol, destCol, skipFirstRow):
"""For converting data in a Calc spreadsheet."""
logger.debug(util.funcName('begin'))
## Start progress bar
progressBar = ProgressBar(self.unoObjs, "Converting...")
progressBar.show()
progressBar.updateBeginning()
## Get list of words from source column
# (just strings are enough, no need for a special object)
reader = SpreadsheetReader(self.unoObjs)
try:
inputList = reader.getColumnStringList(sourceCol, skipFirstRow)
except exceptions.DocAccessError:
self.msgbox.display("Error reading spreadsheet.")
progressBar.close()
if len(inputList) == 0:
self.msgbox.display("Did not find anything in column %s.",
sourceCol)
progressBar.close()
return
if progressBar.getPercent() < 40:
progressBar.updatePercent(40)
## Convert
outList = []
problems = False
numDataChanges = 0
for inValue in inputList:
try:
outValue = self.secCall.convert(inValue)
outList.append(outValue)
if outValue != inValue:
numDataChanges += 1
except exceptions.MessageError as exc:
self.msgbox.displayExc(exc)
problems = True
outList.append("")
break
## Output results
outputter = SpreadsheetOutput(self.unoObjs)
try:
outputter.outputToColumn(destCol, outList, skipFirstRow)
except exceptions.DocAccessError:
self.msgbox.display("Error writing to spreadsheet.")
progressBar.updateFinishing()
progressBar.close()
## Display results
if not problems:
if numDataChanges == 0:
self.msgbox.display("No changes.")
else:
self.msgbox.display("Successfully finished conversion.")
def doConversions_draw(self):
"""For converting data in a Draw doc."""
logger.debug(util.funcName('begin'))
## Start progress bar
progressBar = ProgressBar(self.unoObjs, "Converting...")
progressBar.show()
progressBar.updateBeginning()
## Find the text ranges
shapeSearch = ShapeSearch(self.unoObjs, progressBar)
shapeSearch.setConfig(self.config.searchConfig)
try:
if self.config.whichScope == 'WholeDoc':
shapeSearch.scopeWholeDoc()
elif self.config.whichScope == 'Selection':
shapeSearch.scopeSelection()
elif self.config.whichScope == 'Font':
shapeSearch.scopeFont()
else:
raise exceptions.LogicError("Unexpected value %s",
self.config.whichScope)
except (exceptions.RangeError, exceptions.LogicError) as exc:
self.msgbox.displayExc(exc)
progressBar.close()
return
rangesFound = shapeSearch.getRanges()
if progressBar.getPercent() < 40:
progressBar.updatePercent(40)
## Do the changes to those ranges
textChanger = TextChanger(self.unoObjs, progressBar,
self.changerSettings)
if self.secCall.config.convName:
textChanger.setConverterCall(self.secCall)
textChanger.setFontToChange(self.config.targetFont)
# Apparently, if we change text in front of a range in Draw,
# the range can move. So, start from the end and work backwards.
rangesFound.reverse()
numDataChanges, numStyleChanges = textChanger.doChanges(
rangesFound, self.config.askEach)
progressBar.updateFinishing()
progressBar.close()
## Display results
paragraphsFound = len(rangesFound)
if paragraphsFound == 0:
self.msgbox.display("Did not find scope of change.")
elif numDataChanges == 0:
if numStyleChanges == 0:
self.msgbox.display("No changes.")
else:
plural = "" if numStyleChanges == 1 else "s"
# add "s" if plural
self.msgbox.display(
"No changes, but modified style of %d paragraph%s.",
numStyleChanges, plural)
elif paragraphsFound == 1:
plural = "" if numDataChanges == 1 else "s" # add "s" if plural
self.msgbox.display("Made %d change%s.", numDataChanges, plural)
else:
plural = "" if numDataChanges == 1 else "s" # add "s" if plural
self.msgbox.display("Found %d paragraphs and made %d change%s.",
paragraphsFound, numDataChanges, plural)
class DlgDataConversion:
"""Main class for this dialog."""
def __init__(self, unoObjs):
self.unoObjs = unoObjs
self.userVars = uservars.UserVars(
uservars.Prefix.DATA_CONVERSION, unoObjs.document, logger)
self.msgbox = MessageBox(unoObjs)
self.styleFonts = styles.StyleFonts(unoObjs)
self.app = DataConversion(unoObjs, self.userVars, self.styleFonts)
self.dlgCtrls = None
self.evtHandler = None
self.charStyleNames = []
self.paraStyleNames = []
self.config = None
self.converter = None
self.convertOnClose = False
self.dlgClose = None
def showDlg(self):
logger.debug(util.funcName(obj=self))
dlg = dutil.createDialog(self.unoObjs, _dlgdef)
if not dlg:
return
ctrl_getter = dutil.ControlGetter(dlg)
self.evtHandler = DlgEventHandler(self)
self.dlgCtrls = None
self.dlgCtrls = DlgControls(
self.unoObjs, ctrl_getter, self.evtHandler)
self.evtHandler.setCtrls(self.dlgCtrls)
logger.debug("Getting styles...")
styleNames = styles.getListOfStyles('ParagraphStyles', self.unoObjs)
self.paraStyleNames = dict(styleNames)
paraStyleDispNames = tuple([dispName for dispName, name in styleNames])
styleNames = styles.getListOfStyles('CharacterStyles', self.unoObjs)
self.charStyleNames = dict(styleNames)
charStyleDispNames = tuple([dispName for dispName, name in styleNames])
self.dlgCtrls.loadValues(
self.userVars, paraStyleDispNames, charStyleDispNames)
self.dlgCtrls.enableDisable(self)
## Display the dialog
self.dlgClose = dlg.endExecute
dlg.execute()
if self.convertOnClose:
self.app.doConversions_writer()
dlg.dispose()
def selectTargetFont(self, control, styleType):
"""Selects the font based on the value specified in the control.
If control is None (for initialization or testing), gets values from
user variables instead.
"""
logger.debug(util.funcName('begin'))
listCtrl = self.dlgCtrls.listTargetStyleFont # shorthand variable
listValues = listCtrl.Items
if control:
fontType = 'Western'
if self.dlgCtrls.optTargetFontComplex.getState() == 1:
fontType = 'Complex'
elif self.dlgCtrls.optTargetFontAsian.getState() == 1:
fontType = 'Asian'
displayName = control.getText()
try:
if styleType == 'Paragraph':
styleName = self.paraStyleNames[displayName]
elif styleType == 'Character':
styleName = self.charStyleNames[displayName]
except KeyError:
# Perhaps a new style to be created
logger.debug("%s is not a known style.", displayName)
return
fontName, fontSize = self.styleFonts.getFontOfStyle(
styleType, fontType, styleName)
else:
fontName = self.userVars.get('TargetFontName')
fontSize = FontSize()
fontSize.loadUserVar(self.userVars, 'TargetFontSize')
if fontName and fontName in listValues:
listCtrl.selectItem(fontName, True)
else:
listCtrl.selectItemPos(0, True)
fontSize.changeCtrlVal(self.dlgCtrls.txtFontSize)
def selectConverter(self):
logger.debug(util.funcName('begin'))
logger.debug("Selecting a converter...")
converter = self.app.selectConverter()
self.dlgCtrls.txtConverterName.setText(converter.convName)
self.dlgCtrls.chkDirectionReverse.setState(not converter.forward)
def noConverter(self):
logger.debug(util.funcName('begin'))
logger.debug("Clearing converter...")
self.dlgCtrls.txtConverterName.setText("<No converter>")
def closeAndConvert(self):
logger.debug(util.funcName('begin'))
logger.debug("Closing and Converting...")
self.getFormResults()
try:
self.app.setAndVerifyConverter(self.converter)
self.app.setAndVerifyConfig(self.config)
self.convertOnClose = True
self.dlgClose()
except (exceptions.ChoiceProblem, exceptions.StyleError) as exc:
self.msgbox.displayExc(exc)
def getFormResults(self):
"""Reads form fields and sets self.config and self.converter.
In setAndVerifyConfig() in app layer, the settings will be checked for
inconsistencies.
"""
logger.debug(util.funcName('begin'))
## Converter
self.converter = ConverterSettings(self.userVars)
self.converter.loadUserVars() # for normForm
self.converter.convName = self.dlgCtrls.txtConverterName.getText()
self.converter.forward = (
self.dlgCtrls.chkDirectionReverse.getState() == 0)
self.converter.storeUserVars()
## Radio buttons and the corresponding combo box selection
self.config = ConversionSettings()
searchConfig = self.config.searchConfig # shorthand name
self.config.whichScope = dutil.whichSelected(
self.dlgCtrls.radiosWhichScope)
self.userVars.store('WhichScope', self.config.whichScope)
if self.config.whichScope == 'Font':
searchConfig.fontName = self.dlgCtrls.comboScopeFont.getText()
searchConfig.fontType = dutil.whichSelected(
self.dlgCtrls.radiosScopeFont)
self.userVars.store('ScopeFontType', searchConfig.fontType)
elif self.config.whichScope == 'ParaStyle':
displayName = self.dlgCtrls.comboScopeParaStyle.getText()
# use display name when searching
searchConfig.style = displayName
elif self.config.whichScope == 'CharStyle':
displayName = self.dlgCtrls.comboScopeCharStyle.getText()
if displayName in self.charStyleNames:
searchConfig.style = self.charStyleNames[displayName]
else:
searchConfig.style = displayName
elif self.config.whichScope == 'SFMs':
searchConfig.SFMs = self.dlgCtrls.txtSFM.getText()
searchConfig.load_userVars(self.userVars)
self.config.whichTarget = dutil.whichSelected(
self.dlgCtrls.radiosWhichTarget)
self.userVars.store('WhichTarget', self.config.whichTarget)
self.config.targetStyle = ''
if self.config.whichTarget == 'ParaStyle':
displayName = self.dlgCtrls.comboTargetParaStyle.getText()
if displayName in self.paraStyleNames:
self.config.targetStyle = self.paraStyleNames[displayName]
else:
# Perhaps a new style to be created
self.config.targetStyle = displayName
elif self.config.whichTarget == 'CharStyle':
displayName = self.dlgCtrls.comboTargetCharStyle.getText()
if displayName in self.charStyleNames:
self.config.targetStyle = self.charStyleNames[displayName]
else:
# Perhaps a new style to be created
self.config.targetStyle = displayName
## Target font
targetFontName = self.dlgCtrls.listTargetStyleFont.getSelectedItem()
if targetFontName == "(None)":
targetFontName = None
targetFontSize = FontSize()
targetFontSize.loadCtrl(self.dlgCtrls.txtFontSize)
if self.config.whichTarget == 'FontOnly':
self.userVars.store('TargetFontName', targetFontName)
self.userVars.store('TargetFontSize', targetFontSize.getString())
targetFontType = dutil.whichSelected(
self.dlgCtrls.radiosTargetFont)
self.userVars.store('TargetFontType', targetFontType)
self.config.targetFont = styles.FontDefStruct(
targetFontName, targetFontType, targetFontSize)
self.config.askEach = (self.dlgCtrls.chkVerify.getState() == 1)
## Save selections for next time
for combo in self.dlgCtrls.combos:
self.userVars.store(combo.varname, combo.ctrl.getText())
self.userVars.store('SFM_Markers', self.dlgCtrls.txtSFM.getText())
self.userVars.store('AskEachChange',
str(self.dlgCtrls.chkVerify.getState()))
logger.debug(util.funcName('end'))
class DlgChangerMaker:
"""Main class for this dialog."""
def __init__(self, calcUnoObjs):
self.unoObjs = calcUnoObjs
self.msgbox = MessageBox(self.unoObjs)
finder = uservars.SettingsDocFinder(uservars.Prefix.SPELLING,
self.unoObjs)
self.writerUnoObjs = finder.getWriterDoc()
self.userVars = uservars.UserVars(uservars.Prefix.SPELLING,
self.writerUnoObjs.document, logger)
self.app = ChangerMaker(self.unoObjs, self.userVars)
self.exportOnClose = False
self.dlgCtrls = None
self.evtHandler = None
self.dlgClose = None
def showDlg(self):
logger.debug(util.funcName(obj=self))
dlg = dutil.createDialog(self.unoObjs, _dlgdef)
if not dlg:
return
ctrl_getter = dutil.ControlGetter(dlg)
self.evtHandler = DlgEventHandler(self)
self.dlgCtrls = DlgControls(self.unoObjs, ctrl_getter, self.evtHandler)
self.evtHandler.setCtrls(self.dlgCtrls)
self.dlgCtrls.loadValues(self.userVars)
## Display the dialog
self.dlgClose = dlg.endExecute
dlg.execute()
if self.exportOnClose:
self.app.make()
dlg.dispose()
def showFilePicker(self):
logger.debug(util.funcName('begin'))
filetype = "CCT"
extension = CCT_EXT
if self.dlgCtrls.optXSLT.getState() == 1: # selected
filetype = "XSLT"
extension = XSLT_EXT
logger.debug("Extension %s", extension)
defaultFilename = "spelling_changes" + extension
if filetype == "CCT":
filters = [[
"Consistent Change Table (%s)" % CCT_EXT, "*" + CCT_EXT
]]
elif filetype == "XSLT":
filters = [["XSL Transformations (%s)" % XSLT_EXT, "*" + XSLT_EXT]]
filepath = filepicker.showFilePicker(self.unoObjs, True, filters,
defaultFilename)
logger.debug(repr(filepath))
if filepath == "":
logger.debug("No filepath specified.")
return
if not filepath.lower().endswith(extension):
filepath = "%s%s" % (filepath, extension) # += fails in python3
self.dlgCtrls.txtFilePath.setText(filepath)
logger.debug("set filepath to '%s'", filepath)
def addXpath(self):
logger.debug(util.funcName('begin'))
newValue = self.dlgCtrls.txtXpath.getText()
newValue = newValue.strip()
stringList = dutil.listbox_items(self.dlgCtrls.listXpaths)
logger.debug(repr(stringList))
if newValue in stringList:
self.msgbox.display("This expression is already in the list.")
return
stringList.append(newValue)
stringList.sort()
dutil.fill_list_ctrl(self.dlgCtrls.listXpaths, stringList, newValue)
def removeXpath(self):
logger.debug(util.funcName('begin'))
try:
itemPos = dutil.get_selected_index(self.dlgCtrls.listXpaths)
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
return
self.dlgCtrls.listXpaths.removeItems(itemPos, 1)
# Select the next item
dutil.select_index(self.dlgCtrls.listXpaths, itemPos)
def closeAndExport(self):
logger.debug(util.funcName('begin'))
try:
self.getFormResults()
self.exportOnClose = True
self.dlgClose()
except exceptions.ChoiceProblem as exc:
self.msgbox.displayExc(exc)
except exceptions.UserInterrupt:
pass
def closeDlg(self):
logger.debug(util.funcName('begin'))
self.getFormResults(verify=False)
self.dlgClose()
def getFormResults(self, verify=True):
"""Reads form fields and gets settings.
If verify is True, raises an exception if there is a problem.
"""
logger.debug(util.funcName('begin'))
exportType = ""
if self.dlgCtrls.optReplacementCCT.getState() == 1: # selected
exportType = "ReplacementCCT"
elif self.dlgCtrls.optSFM_CCT.getState() == 1:
exportType = "SFM_CCT"
sfMarkers = self.dlgCtrls.txtSFM.getText().strip()
if verify and sfMarkers == "":
ok = self.msgbox.displayOkCancel(
"No SF markers were specified. Continue anyway?")
if not ok:
raise exceptions.UserInterrupt()
self.userVars.store("SFM_Markers", sfMarkers)
self.app.setSFM(sfMarkers)
elif self.dlgCtrls.optXSLT.getState() == 1:
exportType = "XSLT"
if verify and self.dlgCtrls.listXpaths.getItemCount() == 0:
ok = self.msgbox.displayOkCancel(
"No Xpath expressions were specified. Continue anyway?")
if not ok:
raise exceptions.UserInterrupt()
self.userVars.store("XSLT_MatchPartial",
str(self.dlgCtrls.chkMatchPartial.getState()))
self.app.setMatchPartial(
self.dlgCtrls.chkMatchPartial.getState() == 1)
self.userVars.store("XpathCount",
str(self.dlgCtrls.listXpaths.getItemCount()))
stringList = dutil.listbox_items(self.dlgCtrls.listXpaths)
for exprNum, exprVal in enumerate(stringList):
varname = "XpathExpr%02d" % exprNum
self.userVars.store(varname, exprVal)
self.app.setXpathExprs(stringList)
self.userVars.store("ExportType", exportType)
self.app.setExportType(exportType)
filepath = self.dlgCtrls.txtFilePath.getText().strip()
if verify and filepath == "":
raise exceptions.ChoiceProblem("Please specify a file to export.")
self.userVars.store("Filepath", filepath)
self.app.setFilepath(filepath)
logger.debug(util.funcName('end'))
class ExServices:
"""Services that can conveniently be called from other modules."""
def __init__(self, exType, unoObjs):
self.exType = exType
self.unoObjs = unoObjs
if self.exType == EXTYPE_PHONOLOGY:
USERVAR_PREFIX = Prefix.PHONOLOGY
else:
USERVAR_PREFIX = Prefix.GRAMMAR
self.userVars = UserVars(
USERVAR_PREFIX, unoObjs.document, logger)
self.msgbox = MessageBox(unoObjs)
self.settings = ExSettings(self.exType, self.unoObjs, self.userVars)
self.operations = ExOperations(
self.exType, self.unoObjs, self.userVars, self.settings)
self.replacingRefs = True # find and replace ref numbers
logger.debug("ExGrabber init() finished")
def getAllRefnums(self):
"""Returns an iterable of all ref numbers in the data.
Items are in the order that they were read from the file.
"""
try:
self.operations.readData()
return self.operations.examplesDict.keys()
except exceptions.MessageError as exc:
self.msgbox.displayExc(exc)
def insertByRefnum(self, refTextRough):
try:
self.operations.readData()
if not refTextRough.strip():
raise exceptions.ChoiceProblem(
*self.operations.messageAndSuggestions(
"Please enter a ref number."))
logger.debug("do the insertion.")
self.operations.insertEx(refTextRough, False, False)
except exceptions.MessageError as exc:
self.msgbox.displayExc(exc)
def setUpdateExamples(self, newVal):
self.replacingRefs = not newVal
def isUpdatingExamples(self):
return not self.replacingRefs
def findNext(self, searchFromBeginning):
"""Returns true if a ref number is found."""
logger.debug("findNext(%s)", searchFromBeginning)
oldFoundString = self.operations.getFoundString()
newFoundString = self.operations.doSearch(
self.replacingRefs, searchFromBeginning)
if oldFoundString and not newFoundString:
return bool(oldFoundString)
return bool(newFoundString)
def replace(self, searchFromBeginning):
"""Returns True if another ref number is found after replacing."""
logger.debug(util.funcName('begin'))
if (self.exType == EXTYPE_GRAMMAR and self.isUpdatingExamples() and
not self.settings.getOutconfig().makeOuterTable):
self.msgbox.display(
"To update examples, 'Outer table' must be "
"marked in Grammar Settings.")
return False
if not self.operations.getFoundString():
return self.findNext(searchFromBeginning)
refnumFound = self.operations.getFoundString()
try:
self.operations.readData()
if self.replacingRefs:
self.operations.insertEx(refnumFound, True, False)
else:
self.operations.updateEx(refnumFound)
self.operations.doSearch(self.replacingRefs, False)
except exceptions.MessageError as exc:
self.msgbox.displayExc(exc)
return bool(self.operations.getFoundString())
def replaceAll(self):
"""Replace all #ref no's or update all existing examples."""
if (self.exType == EXTYPE_GRAMMAR and self.isUpdatingExamples() and
not self.settings.getOutconfig().makeOuterTable):
self.msgbox.display(
"To update examples, 'Outer table' must be "
"marked in Grammar Settings.")
return
try:
self.operations.readData()
repeater = ExRepeater(
self.msgbox, self.settings, self.operations,
self.replacingRefs)
repeater.replaceAll()
except exceptions.MessageError as exc:
self.msgbox.displayExc(exc)
def addExampleNumbers(self):
self.operations.addExampleNumbers()