class DlgGrabExamples:
"""Main class for this dialog."""
def __init__(self, exType, unoObjs):
self.exType = exType
self.unoObjs = unoObjs
logger.debug("DlgGrabExamples() %s", exType)
self.msgbox = MessageBox(unoObjs)
if exType == EXTYPE_PHONOLOGY:
USERVAR_PREFIX = Prefix.PHONOLOGY
self.titleText = theLocale.getText("Get Phonology Examples")
else:
USERVAR_PREFIX = Prefix.GRAMMAR
self.titleText = theLocale.getText(
"Get Interlinear Grammar Examples")
self.userVars = UserVars(USERVAR_PREFIX, unoObjs.document, logger)
self.app = lingexamples.ExServices(exType, unoObjs)
self.dlgCtrls = None
self.evtHandler = None
self.dlgClose = None
logger.debug("DlgGrabExamples init() finished")
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)
dlg.setTitle(self.titleText)
self.dlgCtrls.loadValues(self.userVars)
self.dlgCtrls.enableDisable(self.app, self.userVars)
if self.dlgCtrls.single_refnum():
self.dlgCtrls.comboRefnum.setFocus()
else:
self.dlgCtrls.listboxRefnum.setFocus()
self.dlgClose = dlg.endExecute
dlg.execute()
if self.exType == EXTYPE_GRAMMAR:
self.app.addExampleNumbers()
dlg.dispose()
def insertEx(self):
logger.debug(util.funcName('begin'))
if self.dlgCtrls.single_refnum():
ref_texts = [self.dlgCtrls.comboRefnum.getText()]
else:
ref_texts = self.dlgCtrls.listboxRefnum.getSelectedItems()
for ref_text in ref_texts:
self.app.insertByRefnum(ref_text)
self.userVars.store("EXREFNUM", ref_texts[0])
def findNext(self):
logger.debug(util.funcName('begin'))
startFromBeginning = (
self.dlgCtrls.chkStartFromBeginning.getState() == 1)
found = self.app.findNext(startFromBeginning)
if found:
self.dlgCtrls.chkStartFromBeginning.setState(False)
def replace(self):
logger.debug(util.funcName('begin'))
startFromBeginning = (
self.dlgCtrls.chkStartFromBeginning.getState() == 1)
found = self.app.replace(startFromBeginning)
if found:
self.dlgCtrls.chkStartFromBeginning.setState(False)
def replaceAll(self):
logger.debug(util.funcName('begin'))
if self.app.isUpdatingExamples():
result = self.msgbox.displayOkCancel(
"Update all examples now? "
"It is recommended to save a copy of your document first.")
if not result:
return
## Refresh the window
oContainerWindow = self.unoObjs.frame.getContainerWindow()
oContainerWindow.setVisible(False)
oContainerWindow.setVisible(True)
self.dlgCtrls.chkStartFromBeginning.setState(True)
self.app.replaceAll()
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 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 AbbrevList(ItemList, Syncable):
"""Maintains a list of abbreviations."""
ITEM_DESC_GENERIC = "an abbreviation"
ITEM_DESC_SPECIFIC = "Abbreviation"
def __init__(self, unoObjs, userVars):
ItemList.__init__(self)
Syncable.__init__(self, userVars)
self.msgbox = MessageBox(unoObjs)
def getUniqueList(self):
"""Return a lowercased set of the abbreviations."""
newList = [item.abbrevText.lower() for item in self.itemList]
# make the list unique
newList = list(set(newList))
return newList
def loadUserVars(self):
logger.debug(util.funcName())
self.itemList = []
varname = "Abbreviations"
abbrevs_repr = self.userVars.get(varname)
if abbrevs_repr == "":
self.loadDefaultList()
return
## Verify the string is correctly formed, like "(a,b,c,d)(e,f,g,h)"
if not re.search(r'^(?:\(.*,.*,.*,.*\))*$', abbrevs_repr):
self.msgbox.display(
self.noUserVarData(self.userVars.VAR_PREFIX + varname))
return
## Split by parenthesis into tuples.
for abbrev_repr in re.split(r'(?<!\\)[()]', abbrevs_repr):
if abbrev_repr == "":
# Splitting "(a)(b)" by () results in three empty strings:
# initially before "(", medially between ")(",
# and finally after ")". Just ignore these.
continue
newAbbrev = Abbrev()
newAbbrev.loadFromRepr(abbrev_repr)
self.itemList.append(newAbbrev)
self.sortItems()
def storeUserVars(self):
"""The string will look like:
(abbrev1,fullName1,True,0)(abbrev2,fullName2,True,0)
"""
if not self.changed:
return
logger.debug(util.funcName())
abbrevs_repr = "".join(
[repr(abbrev) for abbrev in self.itemList])
self.userVars.store("Abbreviations", abbrevs_repr)
self.changed = False
logger.debug(util.funcName('end'))
def loadDefaultList(self):
"""Loads the default list, taken from Leipzig Glossing Rules."""
logger.debug(util.funcName())
self.itemList = []
defaultAbbrevs = [
("1", "first person"),
("2", "second person"),
("3", "third person"),
("A", "agent-like argument of canonical transitive verb"),
("ABL", "ablative"),
("ABS", "absolutive"),
("ACC", "accusative"),
("ADJ", "adjective"),
("ADV", "adverb(ial)"),
("AGR", "agreement"),
("ALL", "allative"),
("ANTIP", "antipassive"),
("APPL", "applicative"),
("ART", "article"),
("AUX", "auxiliary"),
("BEN", "benefactive"),
("CAUS", "causative"),
("CLF", "classifier"),
("COM", "comitative"),
("COMP", "complementizer"),
("COMPL", "completive"),
("COND", "conditional"),
("COP", "copula"),
("CVB", "converb"),
("DAT", "dative"),
("DECL", "declarative"),
("DEF", "definite"),
("DEM", "demonstrative"),
("DET", "determiner"),
("DIST", "distal"),
("DISTR", "distributive"),
("DU", "dual"),
("DUR", "durative"),
("ERG", "ergative"),
("EXCL", "exclusive"),
("F", "feminine"),
("FOC", "focus"),
("FUT", "future"),
("GEN", "genitive"),
("IMP", "imperative"),
("INCL", "inclusive"),
("IND", "indicative"),
("INDF", "indefinite"),
("INF", "infinitive"),
("INS", "instrumental"),
("INTR", "intransitive"),
("IPFV", "imperfective"),
("IRR", "irrealis"),
("LOC", "locative"),
("M", "masculine"),
("N", "neuter"),
("N", "non- (e.g. NSG nonsingular, NPST nonpast)"),
("NEG", "negation, negative"),
("NMLZ", "nominalizer/nominalization"),
("NOM", "nominative"),
("OBJ", "object"),
("OBL", "oblique"),
("P", "patient-like argument of canonical transitive verb"),
("PASS", "passive"),
("PFV", "perfective"),
("PL", "plural"),
("POSS", "possessive"),
("PRED", "predicative"),
("PRF", "perfect"),
("PRS", "present"),
("PROG", "progressive"),
("PROH", "prohibitive"),
("PROX", "proximal/proximate"),
("PST", "past"),
("PTCP", "participle"),
("PURP", "purposive"),
("Q", "question particle/marker"),
("QUOT", "quotative"),
("RECP", "reciprocal"),
("REFL", "reflexive"),
("REL", "relative"),
("RES", "resultative"),
("S", "single argument of canonical intransitive verb"),
("SBJ", "subject"),
("SBJV", "subjunctive"),
("SG", "singular"),
("TOP", "topic"),
("TR", "transitive"),
("VOC", "vocative")]
for defaultTuple in defaultAbbrevs:
newAbbrev = Abbrev()
newAbbrev.abbrevText, newAbbrev.fullName = defaultTuple
self.itemList.append(newAbbrev)
self.sortItems()
self.changed = True
self.storeUserVars()
def sortItems(self):
"""Sort by abbreviation."""
logger.debug(util.funcName())
self.itemList.sort()
def setOccurrences(self, itemPos, newValue):
self.itemList[itemPos].occurrences = newValue
self.changed = True
def changeAllCaps(self):
"""Rotate between three options:
All caps, all lower, and first char upper.
Returns True if change is made.
"""
allCapsNew = "UPPER"
allCapsPrev = self.userVars.get("AllCaps")
if allCapsPrev == "":
allCapsPrev = "UPPER"
if allCapsPrev == "UPPER":
allCapsNew = "lower"
elif allCapsPrev == "lower":
allCapsNew = "Capitalized"
elif allCapsPrev == "Capitalized":
allCapsNew = "UPPER"
result = self.msgbox.displayOkCancel(
"This will change the case of the entire list from '%s' "
"to '%s.' Continue?", allCapsPrev, allCapsNew)
if not result:
logger.debug("Not changing caps.")
return False
logger.debug("Changing caps.")
for abbr in self.itemList:
if allCapsNew == "UPPER":
abbr.abbrevText = abbr.abbrevText.upper()
elif allCapsNew == "lower":
abbr.abbrevText = abbr.abbrevText.lower()
elif allCapsNew == "Capitalized":
abbr.abbrevText = abbr.abbrevText.capitalize()
else:
self.msgbox.display("Unexpected new value %s.", allCapsNew)
return False
self.changed = True
self.userVars.store("AllCaps", allCapsNew)
return True
class DlgPhonSettings:
"""Main class for this dialog."""
def __init__(self, unoObjs):
self.unoObjs = unoObjs
self.userVars = UserVars(Prefix.PHONOLOGY, unoObjs.document, logger)
self.msgbox = MessageBox(unoObjs)
self.app = lingexamples.ExServices(EXTYPE_PHONOLOGY, unoObjs)
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)
self.dlgClose = dlg.endExecute
dlg.execute()
dlg.dispose()
def selectWritingSys(self):
logger.debug(util.funcName('begin'))
logger.debug("Selecting Writing System...")
filepath = self.dlgCtrls.fileControl.getText()
if not re.search(r"\.lift$", filepath):
self.msgbox.display(
"If you want to use LIFT data, then first specify a "
"LIFT file exported from FieldWorks.")
return
defaultCode = self.dlgCtrls.txtWritingSys.getText()
dlgWS = DlgWritingSystem(defaultCode, self.unoObjs)
dlgWS.readFile(filepath)
if len(dlgWS.writingSystems) == 0:
self.msgbox.display("No writing systems found.")
return
dlgWS.showDlg()
writingSystem = dlgWS.getResult()
dlgWS.call_dispose()
self.dlgCtrls.txtWritingSys.setText(writingSystem.internalCode)
def storeAndClose(self):
logger.debug(util.funcName('begin'))
outSettings = lingex_structs.PhonOutputSettings(self.userVars)
outSettings.showBrackets = bool(
self.dlgCtrls.checkboxBrackets.getState())
outSettings.phonemicLeftmost = bool(
self.dlgCtrls.optionPhonemicFirst.getState())
outSettings.storeUserVars()
inSettings = lingex_structs.PhonInputSettings(self.userVars)
inSettings.filepath = self.dlgCtrls.fileControl.getText()
inSettings.phoneticWS = self.dlgCtrls.txtWritingSys.getText()
inSettings.isLexemePhonetic = bool(
self.dlgCtrls.optionLexemePht.getState())
inSettings.storeUserVars()
try:
self.app.verifyRefnums()
except (exceptions.DataNotFoundError,
exceptions.DataInconsistentError) as exc:
ok = self.msgbox.displayOkCancel(exc.msg, *exc.msg_args)
if not ok:
return
PhonologyStyles(self.unoObjs, self.userVars).createStyles()
PhonologyTags(self.userVars).loadUserVars()
self.dlgClose()
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 DlgInterlinSettings:
"""Main class for this dialog."""
def __init__(self, unoObjs):
self.unoObjs = unoObjs
self.userVars = uservars.UserVars(
uservars.Prefix.INTERLINEAR, unoObjs.document, logger)
self.msgbox = MessageBox(unoObjs)
self.fileItems = fileitemlist.FileItemList(
fileitemlist.LingExFileItem, self.userVars)
self.selectedIndex = -1 # position in listboxFiles
self.app = lingexamples.ExServices(EXTYPE_INTERLINEAR, unoObjs)
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.chkDontUseSegnum.setState(not fileItem.use_segnum)
logger.debug(util.funcName('end'))
def updateFile(self, selectNewItem):
""":param selectNewItem: true to select item after refreshing list"""
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 = not bool(
self.dlgCtrls.chkDontUseSegnum.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.chkDontUseSegnum.setState(True)
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")
try:
self.app.verifyRefnums()
except (exceptions.DataNotFoundError,
exceptions.DataInconsistentError) as exc:
ok = self.msgbox.displayOkCancel(exc.msg, *exc.msg_args)
if not ok:
return
## Modify document settings
try:
interlinStyles = InterlinStyles(self.unoObjs, self.userVars)
interlinStyles.createStyles()
uservars.InterlinTags(self.userVars).loadUserVars()
ctrlText = self.dlgCtrls.txtNumColWidth.getText()
interlinStyles.resizeNumberingCol(
ctrlText, self.dlgCtrls.origNumColWidth)
except (exceptions.ChoiceProblem, exceptions.StyleError) as exc:
self.msgbox.displayExc(exc)
return
self.dlgClose()
class DlgSpellingStep:
"""Main class for this dialog."""
def __init__(self, calcUnoObjs):
self.unoObjs = calcUnoObjs
finder = uservars.SettingsDocFinder(uservars.Prefix.SPELLING,
self.unoObjs)
writerUnoObjs = finder.getWriterDoc()
self.userVars = uservars.UserVars(uservars.Prefix.SPELLING,
writerUnoObjs.document, logger)
self.app = SpellingStepper(self.unoObjs, self.userVars)
self.msgbox = MessageBox(self.unoObjs)
self.maxRow = -1
self.scrollbarAlreadyMoved = 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)
# This fixes two problems, at least on Ubuntu:
# - bar on scrollbar control doesn't show in viewable area
# - cannot set background color of text box
dlg.getPeer().setProperty("NativeWidgetLook", False)
self.dlgCtrls.loadValues(self.userVars, self.app)
## Go to first row
self.dlgCtrls.lblWordText.setText("")
self.dlgCtrls.lblConvertedText.setText("")
dataFound = self.loadData()
if not dataFound:
self.msgbox.display("No data found.")
dlg.dispose()
return
startingRow = "2"
varname = "CurrentRow"
if not self.userVars.isEmpty(varname):
startingRow = self.userVars.get(varname)
self.dlgCtrls.txtRowNum.setText(startingRow) # row 1 contains headings
self.gotoRow()
## Display the dialog
self.dlgClose = dlg.endExecute
dlg.execute()
dlg.dispose()
def loadData(self):
dataLen = self.app.loadData()
logger.debug("Data len: %d", dataLen)
self.maxRow = dataLen + 1 # skip first row
self.dlgCtrls.scrollbarRow.setMaximum(self.maxRow)
self.dlgCtrls.scrollbarRow.setBlockIncrement(dataLen // 20)
return dataLen > 0
def gotoRow(self):
"""Go to a particular row in the spreadsheet and display its
information in the dialog.
"""
logger.debug(util.funcName('begin'))
txtVal = self.dlgCtrls.txtRowNum.getText()
lightRedColor = int("FF8888", 16)
if txtVal.strip() == '':
self.dlgCtrls.txtRowNum.getModel().BackgroundColor = lightRedColor
return
try:
rowNum = int(txtVal)
except ValueError:
logger.warning("Couldn't parse '%s' as integer.", txtVal)
self.dlgCtrls.txtRowNum.getModel().BackgroundColor = lightRedColor
return
if rowNum < 2 or rowNum > self.maxRow:
self.dlgCtrls.txtRowNum.getModel().BackgroundColor = lightRedColor
return
self.dlgCtrls.txtRowNum.getModel().setPropertyToDefault(
"BackgroundColor")
if self.scrollbarAlreadyMoved:
self.scrollbarAlreadyMoved = False
else:
self.dlgCtrls.scrollbarRow.setValue(rowNum)
wordInList = self.app.gotoRow(rowNum)
self.userVars.store("CurrentRow", str(rowNum))
self.dlgCtrls.lblWordText.setText(wordInList.text)
self.dlgCtrls.lblConvertedText.setText(wordInList.converted1)
if wordInList.correction:
self.dlgCtrls.txtCorrection.setText(wordInList.correction)
else:
self.dlgCtrls.txtCorrection.setText(wordInList.text)
dutil.set_tristate_checkbox(self.dlgCtrls.chkIsCorrect,
wordInList.isCorrect)
dutil.fill_list_ctrl(self.dlgCtrls.listSimilarWords,
wordInList.similarWords)
suggestions = []
if self.app.wantSuggestions:
suggestions = self.app.getSuggestions(wordInList.similarWords)
dutil.fill_list_ctrl(self.dlgCtrls.listSuggestions, suggestions)
logger.debug(util.funcName('end'))
def enableDisable(self):
newVal = self.dlgCtrls.txtCorrection.getText()
wordInList = self.app.currentRowData()
if newVal == wordInList.text or newVal == wordInList.correction:
self.dlgCtrls.btnSetCorrection.getModel().Enabled = False
else:
self.dlgCtrls.btnSetCorrection.getModel().Enabled = True
def setCorrection(self):
logger.debug("Setting Correction...")
if self.dlgCtrls.chkIsCorrect.getState() == dutil.CHECKED:
ok = self.msgbox.displayOkCancel(
"This word was already set to correct. Change anyway?")
if not ok:
return
correctionStr = self.dlgCtrls.txtCorrection.getText()
self.app.setCorrection(correctionStr)
if correctionStr.strip() == "":
self.app.setIsCorrect(True)
self.dlgCtrls.chkIsCorrect.setState(dutil.CHECKED)
else:
self.app.setIsCorrect(False)
self.dlgCtrls.chkIsCorrect.setState(dutil.UNCHECKED)
self.enableDisable()
def checkSuggestions(self):
self.userVars.store("GiveSuggestions",
str(self.dlgCtrls.chkSuggestions.getState()))
if self.dlgCtrls.chkSuggestions.getState() == 1:
self.app.wantSuggestions = True
else:
self.app.wantSuggestions = False
self.gotoRow()