def _init_translation(qt_app):
"""Sets up translation data for the application.
qt_app -- The QApplication that is being set up.
"""
# Set up translation for Qt's built-in strings.
qt_translator = QTranslator(qt_app)
if not qt_translator.load(
'qt_' + QLocale.system().name(),
QLibraryInfo.location(QLibraryInfo.TranslationsPath)):
# TODO: Log the failure to load translation information.
pass
elif not qt_app.installTranslator(qt_translator):
# TODO: Log the failure to install translation information.
pass
# Set up translation for app-specific strings.
app_translator = QTranslator(qt_app)
app_translations_path = QDir.toNativeSeparators('./qt_qm/translations')
if not app_translator.load('scriptaseq_' + QLocale.system().name(),
app_translations_path):
# TODO: Log the failure to load translation information.
pass
elif not qt_app.installTranslator(app_translator):
# TODO: Log the failure to load translation information.
pass
def on_bridge_ready(self):
f = QApplication.instance().font()
fi = QFontInfo(f)
family = f.family()
if family in ('.AppleSystemUIFont', 'MS Shell Dlg 2'):
family = 'system-ui'
ui_data = {
'all_font_families':
QFontDatabase().families(),
'ui_font_family':
family,
'ui_font_sz':
'{}px'.format(fi.pixelSize()),
'show_home_page_on_ready':
self.show_home_page_on_ready,
'system_colors':
system_colors(),
'QT_VERSION':
QT_VERSION,
'short_time_fmt':
QLocale.system().timeFormat(QLocale.FormatType.ShortFormat),
}
self.bridge.create_view(vprefs['session_data'],
vprefs['local_storage'],
field_metadata.all_metadata(), ui_data)
for func, args in iteritems(self.pending_bridge_ready_actions):
getattr(self.bridge, func)(*args)
def _onLanguagesReceived(self, languages):
loc = QLocale.system()
sysLang = QLocale.languageToString(loc.language())
preferredLanguages = self._getPreferredLanguages()
self._langList.clear()
firstCheckedItem = None
for lang in sorted(languages, key=lambda x: x['name']):
langName = lang['name']
langCode = lang['code']
nativeLang = self._getNativeLanguageName(langName)
text = langName
isSystemLang = langName == sysLang
if nativeLang and not isSystemLang:
text += " (" + nativeLang + ")"
item = QListWidgetItem(text)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setData(Qt.UserRole, langCode)
if (preferredLanguages and langCode in preferredLanguages) \
or isSystemLang:
item.setCheckState(Qt.Checked)
firstCheckedItem = item
else:
item.setCheckState(Qt.Unchecked)
self._langList.addItem(item)
self._langList.setMinimumWidth(self._langList.sizeHintForColumn(0))
if firstCheckedItem:
self._langList.scrollToItem(firstCheckedItem)
class Runner():
_window = None
_application = None
def __init__(self):
self._application = QApplication(sys.argv)
self._window = None
# Main Window Initialized..
try:
self._window = yali.gui.YaliWindow.Widget()
except yali.Error, msg:
ctx.logger.debug(msg)
sys.exit(1)
self._translator = QTranslator()
self._translator.load(
"qt_" + QLocale.system().name(),
QLibraryInfo.location(QLibraryInfo.TranslationsPath))
ctx.mainScreen = self._window
screens = self._get_screens(ctx.flags.install_type)
self._set_steps(screens)
# These shorcuts for developers :)
prevScreenShortCut = QShortcut(QKeySequence(Qt.SHIFT + Qt.Key_F1),
self._window)
nextScreenShortCut = QShortcut(QKeySequence(Qt.SHIFT + Qt.Key_F2),
self._window)
prevScreenShortCut.activated.connect(self._window.slotBack)
nextScreenShortCut.activated.connect(self._window.slotNext)
# VBox utils
ctx.logger.debug("Starting VirtualBox tools..")
#FIXME:sh /etc/X11/Xsession.d/98-vboxclient.sh
yali.util.run_batch("VBoxClient", ["--autoresize"])
yali.util.run_batch("VBoxClient", ["--clipboard"])
# Cp Reboot, ShutDown
yali.util.run_batch("cp", ["/sbin/reboot", "/tmp/reboot"])
yali.util.run_batch("cp", ["/sbin/shutdown", "/tmp/shutdown"])
# base connections
self._application.lastWindowClosed.connect(self._application.quit)
self._window.signalProcessEvents.connect(
self._application.processEvents) #hata olabilir
self._application.desktop().resized[int].connect(
self._reinit_screen) #hata olabilir
# Font Resize
fontMinusShortCut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_Minus),
self._window)
fontPlusShortCut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_Plus),
self._window)
fontMinusShortCut.activated.connect(self._window.setFontMinus)
fontPlusShortCut.activated.connect(self._window.setFontPlus)
def test_get_current_language(self):
install_translators("ru_RU")
self.assertEqual(get_current_language(), "ru_RU")
install_translators("en_EN")
self.assertEqual(get_current_language(), "en_EN")
install_translators()
if QLocale.system().name() == "ru_RU":
self.assertEqual(get_current_language(), "ru_RU")
def __init__(self, parent: QWidget, config, **params):
super(TextEditor, self).__init__(None)
self._parent = parent
# add keys for local vars
for p in ["PlainText", "Font", "FontSize", "ShowLineNumbers",
"WordWrap", "HighlightCurrentLine", "ShowToolBar",
"ShowStatusBar", "AutoSave"]:
params["TextEditor/" + p] = ""
textmode = "format" in params and params["format"].upper() != "HTML"
self._load = params["load"] if "load" in params else lambda: ""
self._save = params["save"] if "save" in params else lambda x: True
self._cfg = ConfigHelper(config, **params)
self._init_params_in_cfg()
self._set_vars(textmode)
self._doc = Doc(self._cfg)
margins = params["margins"] if "margins" in params else None
self._view = View(self, self._cfg, margins)
self._spell = params["spell"] if "spell" in params else None
if not self._spell:
self._spell = SpellChecker()
self._spell.change_enabled.connect(self._rehighlight)
auto_key_switch = "auto_key_switch" in params
cond1 = auto_key_switch and not params["auto_key_switch"]
cond2 = not auto_key_switch and QLocale.system().name() == "en_EN"
if cond1 or cond2:
self._keyswitcher = None # pragma: no cover
else:
self._keyswitcher = KeySwitcher(self._view.text, self._spell)
self._highlighter = ""
self._highlighter_cls = None
self._set_highlighter(self._highlighter)
self._view.text.setAcceptRichText(
not self._cfg.get("TextEditor/PlainText", 0))
self._actions: Dict[str, QAction] = {}
self._make_actions()
self._bind_controls()
# code for copying text format
self._current_format = self._view.text.currentCharFormat()
self._copy_format_mode = TextEditor.NORMAL_MODE
self._cursor_to_change_word = None
if "layout" in params:
params["layout"].addWidget(self) # pragma: no cover
if "auto_load" in params and params["auto_load"]:
self.load()
def test_install_translators(self):
install_translators("ru_RU")
txt = QCoreApplication.translate("@default", "Question")
self.assertEqual(txt, "Вопрос") # i18n
install_translators("en_EN")
txt = QCoreApplication.translate("@default", "Question")
self.assertEqual(txt, "Question")
install_translators()
if QLocale.system().name() == "ru_RU":
txt = QCoreApplication.translate("@default", "Question")
self.assertEqual(txt, "Вопрос") # i18n
def defaultLanguage(cls):
'''
@return: QStringList
'''
longCode = QLocale.system().name().replace('_', '-')
if len(longCode) == 5:
ret = [longCode, longCode[:2]]
return ret
return [longCode]
def value(self, key, localized=False):
if not self._settings:
return None
if localized:
locale = QLocale.system()
localeKey = '%s[%s]' % (key, locale.name())
if self._settings.contains(localeKey):
return self._settings.value(localeKey)
localeKey = '%s[%s]' % (key, locale.bcp47Name())
if self._settings.contains(localeKey):
return self._settings.value(localeKey)
idx = locale.name().index('_')
if idx > 0:
localeKey = '%s[%s]' % (key, locale.name()[:idx])
if self._settings.contains(localeKey):
return self._settings.value(localeKey)
return self._settings.value(key)
