Python localization._translate函数代码示例

    def onCopyCalib(self, event):
        """Creates a new calibration entry for the monitor.
        Note that the calibration date will reflect the save date/time
        """

        # use time as initial guess at name
        calibTime = time.localtime()
        calibTimeStr = monitors.strFromDate(calibTime)

        # then use dialogue so user can override
        msg = _translate(
            'Name of this calibration (for monitor "%(name)s") will be:)')
        infoStr = msg % {'name': self.currentMon.name}
        dlg = wx.TextEntryDialog(self, message=infoStr,
                                 defaultValue=calibTimeStr,
                                 caption=_translate('Input text'))
        if dlg.ShowModal() == wx.ID_OK:
            newCalibName = dlg.GetValue()
            # update the GUI to reflect new calibration
            self.currentMon.copyCalib(newCalibName)
            self.currentMon.setCalibDate(calibTime)

            self.onChangeCalibSelection(1, newCalibName)
            self.updateCalibList()
            self.unSavedMonitor = True
        dlg.Destroy()

    def __init__(self, parent, levels):

        wx.Dialog.__init__(self, parent, -1,
                           _translate('Recorded luminance values'),
                           style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)
        pad = 5
        panel = wx.Panel(self, -1)
        mainSizer = wx.BoxSizer(wx.VERTICAL)
        mainSizer.Add(self.makeCalibBox(parent=panel, levels=levels), 1,
                      wx.EXPAND | wx.ALL, pad)

        butBox = wx.BoxSizer(wx.HORIZONTAL)
        btnOK = wx.Button(panel, wx.ID_OK, _translate(" OK "))
        btnOK.SetDefault()
        btnCANC = wx.Button(panel, wx.ID_CANCEL, _translate(" Cancel "))

        butBox.Add(btnOK, 1, wx.BOTTOM | wx.ALIGN_RIGHT, pad)
        butBox.Add(btnCANC, 1, wx.BOTTOM | wx.RIGHT | wx.ALIGN_RIGHT, pad)
        mainSizer.Add(butBox, flag=wx.ALIGN_CENTER | wx.TOP | wx.BOTTOM,
                      border=10)

        # finalise panel layout
        panel.SetAutoLayout(True)
        panel.SetSizerAndFit(mainSizer)
        mainSizer.Layout()
        self.SetSize(self.GetBestSize())

 def onNewMon(self, event):
     # open a dialogue to get the name
     dlg = wx.TextEntryDialog(self, _translate('New monitor name:'),
                              caption=_translate('Input text'))
     if dlg.ShowModal() == wx.ID_OK:
         self.currentMonName = dlg.GetValue()
         self.ctrlMonList.Append(self.currentMonName)
         self.ctrlMonList.SetStringSelection(self.currentMonName)
         self.currentMon = monitors.Monitor(
             self.currentMonName, verbose=True)
         self.updateCalibList()
         self.onChangeCalibSelection(event=1)
         self.unSavedMonitor = True
     dlg.Destroy()

    def __init__(self, title=_translate('PsychoPy Dialog'),
                 pos=None, size=None, style=None,
                 labelButtonOK=_translate(" OK "),
                 labelButtonCancel=_translate(" Cancel "),
                 screen=-1):

        global app  # avoid recreating for every gui
        app = ensureQtApp()
        QtWidgets.QDialog.__init__(self, None, Qt.WindowTitleHint)

        self.inputFields = []
        self.inputFieldTypes = []
        self.inputFieldNames = []
        self.data = []
        self.irow = 0

        # QtWidgets.QToolTip.setFont(QtGui.QFont('SansSerif', 10))

        # add buttons for OK and Cancel
        self.buttonBox = QtWidgets.QDialogButtonBox(Qt.Horizontal,
                                                    parent=self)
        self.okbutton = QtWidgets.QPushButton(labelButtonOK,
                                              parent=self)
        self.cancelbutton = QtWidgets.QPushButton(labelButtonCancel,
                                                  parent=self)
        self.buttonBox.addButton(self.okbutton,
                                 QtWidgets.QDialogButtonBox.ActionRole)
        self.buttonBox.addButton(self.cancelbutton,
                                 QtWidgets.QDialogButtonBox.ActionRole)
        self.okbutton.clicked.connect(self.accept)
        self.cancelbutton.clicked.connect(self.reject)

        if style:
            raise RuntimeWarning("Dlg does not currently support the "
                                 "style kwarg.")

        self.pos = pos
        self.size = size
        self.screen = screen
        # self.labelButtonOK = labelButtonOK
        # self.labelButtonCancel = labelButtonCancel

        self.layout = QtWidgets.QGridLayout()
        self.layout.setColumnStretch(1, 1)
        self.layout.setSpacing(10)
        self.layout.setColumnMinimumWidth(1, 250)

        self.setLayout(self.layout)

        self.setWindowTitle(title)

    def test_set(self):
        lang = localization.getID('En_US')
        assert lang == 'en'

        for lang in ['En_US', 'Ja_JP', 'ja_JP']:
            setlang = localization.getID(lang)
            out = _translate(welcome)
            assert setlang == lang.lower()[:2]
            assert out == trans[setlang]

 def __init__(self, title=_translate('PsychoPy dialogue'),
              pos=None, size=wx.DefaultSize,
              style=wx.DEFAULT_DIALOG_STYLE | wx.DIALOG_NO_PARENT,
              labelButtonOK=_translate(" OK "),
              labelButtonCancel=_translate(" Cancel ")):
     style = style | wx.RESIZE_BORDER
     global app  # avoid recreating for every gui
     app = ensureWxApp()
     super().__init__(parent=None, id=-1, title=title, style=style)
     self.inputFields = []
     self.inputFieldTypes = []
     self.inputFieldNames = []
     self.data = []
     # prepare a frame in which to hold objects
     self.sizer = wx.BoxSizer(wx.VERTICAL)
     # self.addText('')  # insert some space at top of dialogue
     self.pos = pos
     self.labelButtonOK = labelButtonOK
     self.labelButtonCancel = labelButtonCancel

    def onBtnFindPhotometer(self, event):

        # safer to get by index, but GetStringSelection will work for
        # nonlocalized techincal names:
        photName = self.ctrlPhotomType.GetStringSelection()
        # not sure how
        photPort = self.ctrlPhotomPort.GetValue().strip()
        # [0] == Scan all ports
        if not photPort or photPort == self._photomChoices[0]:
            photPort = None
        elif photPort.isdigit():
            photPort = int(photPort)
        # search all ports
        self.comPortLabel.SetLabel(_translate('Scanning ports...'))
        self.Update()
        self.photom = hardware.findPhotometer(device=photName, ports=photPort)
        if self.photom is not None and self.photom.OK:
            self.btnFindPhotometer.Disable()
            self.btnCalibrateGamma.Enable(True)
            self.btnTestGamma.Enable(True)
            if hasattr(self.photom, 'getLastSpectrum'):
                self.btnCalibrateColor.Enable(True)
            msg = _translate('%(photomType)s found on %(photomPort)s')
            self.comPortLabel.SetLabel(msg %
                                       {'photomType': self.photom.type,
                                        'photomPort': self.photom.portString})
        else:
            self.comPortLabel.SetLabel(_translate('No photometers found'))
            self.photom = None

        # does this device need a dark calibration?
        if (hasattr(self.photom, 'getNeedsCalibrateZero') and
                self.photom.getNeedsCalibrateZero()):
            # prompt user if we need a dark calibration for the device
            if self.photom.getNeedsCalibrateZero():
                dlg = wx.Dialog(self, title=_translate(
                    'Dark calibration of ColorCAL'))
                msg = _translate('Your ColorCAL needs to be calibrated first.'
                                 ' Please block all light from getting into '
                                 'the lens and press OK.')
                while self.photom.getNeedsCalibrateZero():
                    txt = _translate('Dark calibration of ColorCAL')
                    dlg = dialogs.MessageDialog(self, message=msg,
                                                title=txt,
                                                type='Info')
                    # info dlg has only an OK button
                    resp = dlg.ShowModal()
                    if resp == wx.ID_CANCEL:
                        self.photom = None
                        self.comPortLabel.SetLabel('')
                        return 0
                    elif resp == wx.ID_OK:
                        self.photom.calibrateZero()
                    # this failed at least once. Try again.
                    msg = _translate('Try again. Cover the lens fully and '
                                     'press OK')

 def summary(self, items=None):
     """Return a list of (item, color) for gui display. For non-fatal items
     """
     config = {}
     for item in items:
         config[item[0]] = [item[1], item[2], item[3]]  # [3] = warn or not
     green = '#009933'
     red = '#CC3300'
     check = u"\u2713   "
     summary = [(check + _translate('video card drivers'), green)]
     ofInterest = ('python version', 'available memory', 'openGL version',
                   'visual sync (refresh)', 'refresh stability (SD)',
                   'no dropped frames', 'internet access')
     # ofInterest.append('background processes')
     for item in ofInterest:
         if not item in config.keys():
             continue  # eg, microphone latency
         if config[item][2]:  # warn True
             summary.append(("X   " + _translate(item), red))
         else:
             summary.append((check + _translate(item), green))
     return summary

def fileOpenDlg(tryFilePath="",
                tryFileName="",
                prompt=_translate("Select file to open"),
                allowed=None):
    """A simple dialogue allowing read access to the file system.

    :parameters:

        tryFilePath: string
            default file path on which to open the dialog

        tryFileName: string
            default file name, as suggested file

        prompt: string (default "Select file to open")
            can be set to custom prompts

        allowed: string (available since v1.62.01)
            a string to specify file filters.
            e.g. "Text files (\*.txt) ;; Image files (\*.bmp \*.gif)"
            See http://pyqt.sourceforge.net/Docs/PyQt4/qfiledialog.html
            #getOpenFileNames
            for further details

    If tryFilePath or tryFileName are empty or invalid then
    current path and empty names are used to start search.

    If user cancels, then None is returned.
    """
    global qtapp  # avoid recreating for every gui
    qtapp = ensureQtApp()

    if allowed is None:
        allowed = ("All files (*.*);;"
                   "PsychoPy Data (*.psydat);;"
                   "txt (*.txt *.dlm *.csv);;"
                   "pickled files (*.pickle *.pkl);;"
                   "shelved files (*.shelf)")
    fdir = os.path.join(tryFilePath, tryFileName)
    filesToOpen = QtWidgets.QFileDialog.getOpenFileNames(parent=None,
                                                         caption=prompt,
                                                         directory=fdir,
                                                         filter=allowed)
    if type(filesToOpen) == tuple:  # some versions(?) of PyQt return (files, filter)
        filesToOpen = filesToOpen[0]

    filesToOpen = [str(fpath) for fpath in filesToOpen
                   if os.path.exists(fpath)]
    if len(filesToOpen) == 0:
        return None
    return filesToOpen

    def makeCalibBox(self, parent, levels):
        '''do my best to make a calibration box'''
        gammaBox = wx.StaticBox(parent, -1, _translate('Luminance Values'))
        gammaBox.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.NORMAL))
        gammaBoxSizer = wx.StaticBoxSizer(gammaBox, wx.VERTICAL)

        theCols = map(str, levels)
        self.gammaGrid = SimpleGrid(parent, id=-1,
                                    cols=theCols,
                                    rows=['lum', 'R', 'G', 'B'])
        gammaBoxSizer.Add(self.gammaGrid)
        grid.EVT_GRID_CELL_CHANGE(self.gammaGrid, self.onChangeGammaGrid)
        gammaBoxSizer.Layout()

        return gammaBoxSizer

def fileSaveDlg(initFilePath="", initFileName="",
                prompt=_translate("Select file to save"),
                allowed=None):
    """A simple dialogue allowing write access to the file system.
    (Useful in case you collect an hour of data and then try to
    save to a non-existent directory!!)

    :parameters:

        initFilePath: string
            default file path on which to open the dialog

        initFileName: string
            default file name, as suggested file

        prompt: string (default "Select file to open")
            can be set to custom prompts

        allowed: string
            A string to specify file filters.
            e.g. "BMP files (*.bmp)|*.bmp|GIF files (*.gif)|*.gif"
            See http://www.wxpython.org/docs/api/wx.FileDialog-class.html
            for further details

    If initFilePath or initFileName are empty or invalid then
    current path and empty names are used to start search.

    If user cancels the None is returned.
    """
    if allowed is None:
        allowed = "All files (*.*)|*.*"
        # "txt (*.txt)|*.txt"
        # "pickled files (*.pickle, *.pkl)|*.pickle"
        # "shelved files (*.shelf)|*.shelf"
    global app  # avoid recreating for every gui
    app = ensureWxApp()
    dlg = wx.FileDialog(None, prompt, initFilePath,
                        initFileName, allowed, wx.SAVE)
    if dlg.ShowModal() == OK:
        # get names of images and their directory
        outName = dlg.GetFilename()
        outPath = dlg.GetDirectory()
        dlg.Destroy()
        # tmpApp.Destroy()  # this causes an error message for some reason
        fullPath = os.path.join(outPath, outName)
    else:
        fullPath = None
    return fullPath

 def onDeleteCalib(self, event):
     calToDel = self.ctrlCalibList.GetStringSelection()
     # warn user that data will be lost
     msg = _translate('Are you sure you want to delete this calibration? '
                      '(cannot be undone)')
     dlg = dialogs.MessageDialog(parent=self,
                                 message=msg,
                                 type='Warning')
     if dlg.ShowModal() == wx.ID_YES:
         # delete it
         self.currentMon.delCalib(calToDel)
         # load most recent calibration instead
         # this will load calibration "-1" (last calib)
         self.onChangeCalibSelection(event=None, newCalib=-1)
         self.updateCalibList()
     dlg.Destroy()

 def onCloseWindow(self, event):
     if self.unSavedMonitor:
         # warn user that data will be lost
         msg = _translate(
             'Save changes to monitor settings before quitting?')
         dlg = dialogs.MessageDialog(self, message=msg, type='Warning')
         resp = dlg.ShowModal()
         if resp == wx.ID_CANCEL:
             return 1  # return before quitting
         elif resp == wx.ID_YES:
             # save then quit
             self.currentMon.saveMon()
         elif resp == wx.ID_NO:
             pass  # don't save just quit
         dlg.Destroy()
     self.onCopyMon()  # save current monitor name to clipboard
     self.Destroy()

    def plotSpectra(self, event=None):
        msg = _translate('%(monName)s %(calibName)s Spectra')
        figTitle = msg % {'monName': self.currentMonName,
                          'calibName': self.currentCalibName}
        plotWindow = PlotFrame(self, 1003, figTitle)
        figure = Figure(figsize=(5, 5), dpi=80)
        figureCanvas = FigureCanvas(plotWindow, -1, figure)
        plt = figure.add_subplot(111)
        plt.hold('off')

        nm, spectraRGB = self.currentMon.getSpectra()
        if nm != None:
            plt.plot(nm, spectraRGB[0, :], 'r-', linewidth=1.5)
            plt.hold('on')
            plt.plot(nm, spectraRGB[1, :], 'g-', linewidth=2)
            plt.plot(nm, spectraRGB[2, :], 'b-', linewidth=2)
        figureCanvas.draw()  # update the canvas
        plotWindow.addCanvas(figureCanvas)

 def onDeleteMon(self, event):
     monToDel = self.currentMonName
     msg = _translate('Are you sure you want to delete all details for %s? '
                      '(cannot be undone)')
     dlg = dialogs.MessageDialog(parent=self, message=msg % monToDel,
                                 type='Warning')
     response = dlg.ShowModal()
     dlg.Destroy()
     if response == wx.ID_YES:
         # delete it
         monitorFileName = os.path.join(monitors.monitorFolder,
                                        monToDel + ".calib")
         os.remove(monitorFileName)
         self.currentMon = None
         self.currentMonName = None
         self.updateMonList()
         # load most recent calibration instead
         # this will load calibration "-1" (last calib)
         self.onChangeMonSelection(event=None)
         self.updateCalibList()