def main():
sys.excepthook = exception_logger
os.environ['QT_MAC_WANTS_LAYER'] = '1' # Workaround for https://bugreports.qt.io/browse/QTBUG-87014
own_path = os.path.dirname(os.path.realpath(__file__)) + os.sep
error = init_and_check_db(own_path)
if error.code == LedgerInitError.EmptyDbInitialized: # If DB was just created from SQL - initialize it again
error = init_and_check_db(own_path)
app = QApplication([])
language = get_language()
translator = QTranslator(app)
language_file = own_path + "languages" + os.sep + language + '.qm'
translator.load(language_file)
app.installTranslator(translator)
if error.code == LedgerInitError.OutdatedDbSchema:
error = update_db_schema(own_path)
if error.code == LedgerInitError.DbInitSuccess:
error = init_and_check_db(own_path)
if error.code != LedgerInitError.DbInitSuccess:
window = QMessageBox()
window.setAttribute(Qt.WA_DeleteOnClose)
window.setWindowTitle("JAL: Start-up aborted")
window.setIcon(QMessageBox.Critical)
window.setText(error.message)
window.setInformativeText(error.details)
else:
window = MainWindow(own_path, language)
window.show()
app.exec_()
app.removeTranslator(translator)
def run_GUI(argv):
# Default material data path
# Script to be used to test in dev
a = QApplication(argv)
# Set CSS
# a.setStyleSheet("QLineEdit { background-color: yellow }")
# Setup the translation
translationFile = "pyleecan_fr.qm"
translator = QTranslator()
translator.load(translationFile, "GUI//i18n")
a.installTranslator(translator)
if isfile(config_dict["GUI"]["CSS_PATH"]):
with open(config_dict["GUI"]["CSS_PATH"], "r") as css_file:
a.setStyleSheet(css_file.read())
# Load Material Library
material_dict = load_matlib(machine=None,
matlib_path=config_dict["MAIN"]["MATLIB_DIR"])
# MatLib widget
mat_widget = DMatLib(material_dict=material_dict)
# Machine Setup Widget
c = DMachineSetup(material_dict=material_dict,
machine_path=config_dict["MAIN"]["MACHINE_DIR"])
if EXT_GUI:
# Setup extended GUI with sub windows
icon = pixmap_dict["soft_icon"]
window = SidebarWindow()
window.setWindowIcon(QIcon(icon))
update_step = lambda: c.set_nav(c.nav_step.currentRow())
window.addSubWindow("Design", c, update_step)
window.DesignWidget = c
plt_widget = MachinePlotWidget(window)
window.addSubWindow("Plot", plt_widget, plt_widget.update)
mat_widget.installEventFilter(window)
window.addSubWindow("MatLib", mat_widget,
mat_widget.update_treeview_material)
tree = WTreeEdit(c.machine)
tree_fcn = lambda: tree.update(getattr(c, "machine"))
window.addSubWindow("TreeEdit", tree, tree_fcn)
option = WGuiOption(machine_setup=c, matlib=mat_widget)
window.addSubWindow("Option", option)
window.show()
else:
# "Normal" GUI
c.show()
exit(a.exec_())
def run_GUI(argv):
# Default material data path
# Script to be used to test in dev
a = QApplication(argv)
# Set CSS
# a.setStyleSheet("QLineEdit { background-color: yellow }")
# Setup the translation
translationFile = "pyleecan_fr.qm"
translator = QTranslator()
translator.load(translationFile, "GUI//i18n")
a.installTranslator(translator)
if isfile(config_dict["GUI"]["CSS_PATH"]):
with open(config_dict["GUI"]["CSS_PATH"], "r") as css_file:
a.setStyleSheet(css_file.read())
# Setting the material library
matlib = MatLib(config_dict["MAIN"]["MATLIB_DIR"])
# MatLib widget
mat_widget = DMatLib(matlib, selected=0)
# Machine Setup Widget
c = DMachineSetup(dmatlib=mat_widget,
machine_path=config_dict["MAIN"]["MACHINE_DIR"])
if EXT_GUI:
# Setup extended GUI with sub windows
icon = dirname(__file__) + "/GUI/Resources/images/icon/pyleecan_64.png"
window = SidebarWindow()
window.setWindowIcon(QIcon(icon))
update_step = lambda: c.set_nav(c.nav_step.currentRow())
window.addSubWindow("Design", c, update_step)
window.DesignWidget = c
plt_widget = MachinePlotWidget(window)
window.addSubWindow("Plot", plt_widget, plt_widget.update)
mat_widget.installEventFilter(window)
window.addSubWindow("MatLib", mat_widget, mat_widget.update_list_mat)
tree = TreeView()
tree_fcn = lambda: tree.generate(getattr(c, "machine"))
window.addSubWindow("TreeView", tree, tree_fcn)
option = WGuiOption(machine_setup=c, matlib=matlib)
window.addSubWindow("Option", option)
window.show()
else:
# "Normal" GUI
c.show()
exit(a.exec_())
def start():
app = QApplication(sys.argv)
app.setOrganizationName('Quring')
app.setOrganizationDomain('Quring')
app.setApplicationName('Quring')
qt_translator = QTranslator()
qt_translator.load('qt_' + QLocale.system().name(),
QLibraryInfo.location(QLibraryInfo.TranslationsPath))
app.installTranslator(qt_translator)
main_window = MainWindow()
logger.info('Showing main window')
main_window.show()
sys.exit(app.exec_())
def launch_qt_gui(bk, prefs):
supports_theming = (bk.launcher_version() >= 20200117)
app = QApplication(sys.argv)
# Make plugin match Sigil's light/dark theme
if supports_theming:
if bk.colorMode() == "dark":
app.setStyle(QStyleFactory.create("Fusion"))
app.setPalette(dark_palette(bk.color))
print('Application dir: {}'.format(QCoreApplication.applicationDirPath()))
# Install qtbase translator for standard dialogs and such.
# Use the Sigil language setting unless manually overridden.
qt_translator = QTranslator()
if prefs['language_override'] is not None:
print('Plugin preferences language override in effect')
qmf = 'qtbase_{}'.format(prefs['language_override'])
else:
qmf = 'qtbase_{}'.format(bk.sigil_ui_lang)
# Get bundled or external translations directory
qt_trans_dir = getQtTranslationsPath(bk._w.appdir)
print('Qt translation dir: {}'.format(qt_trans_dir))
print('Looking for {} in {}'.format(qmf, qt_trans_dir))
qt_translator.load(qmf, qt_trans_dir)
print('Translator succesfully installed: {}'.format(
app.installTranslator(qt_translator)))
ex = App(bk, prefs)
ex.show()
app.exec_()
return _DETAILS
def main():
logging.info("pyOffer version %s started at %s", version, datetime.now())
locale_set = locale.setlocale(locale.LC_ALL, '')
logging.info("System locale: %s", locale_set)
app = QApplication(sys.argv)
app.setOrganizationName("KonserwSoft")
app.setApplicationName("pyOffer")
lang = QLocale.system().name()[0:2]
logging.info("Loading translation for: %s", lang)
translator = QTranslator()
if translator.load(f"translations/{lang}"):
app.installTranslator(translator)
logging.info("Loaded translations from: %s", f"translations/{lang}")
else:
logging.warning("Failed to load translations from: %s",
f"translations/{lang}")
settings = QSettings()
settings.beginGroup("database")
host_name = settings.value("host_name", "127.0.0.1")
port = int(settings.value("port", "5432"))
database_name = settings.value("database_name", "koferta_test")
user_name = settings.value("user_name", "postgres")
password = settings.value("password", "docker")
settings.endGroup()
try:
logging.info("DB host name: %s", host_name)
logging.info("DB port: %s", port)
logging.info("DB database name: %s", database_name)
logging.info("DB user name: %s", user_name)
database.connect(host_name, database_name, user_name, password, port)
except RuntimeError as e:
QMessageBox.critical(
None, app.tr("Database connection failed"),
app.tr(f"Driver error: {e.args[1]}\nDatabase error: {e.args[2]}"))
return str(e)
user_dialog = UserSelectionDialog.make()
if user_dialog.exec_() == QDialog.Accepted:
logging.debug("User dialog accepted")
user = User.from_sql_record(user_dialog.chosen_user_record)
logging.info("Chosen user: %s", user)
main_window = MainWindow(user)
main_window.show()
return app.exec_()
logging.info("User hasn't been chosen - exiting")
return 0
def main():
# app disexec теперь на pyqt
app = QApplication(sys.argv)
app.setStyle('Fusion')
# Здесь будем работать со стилями(пока в разработке)
#QApplication.setStyle(QStyleFactory.create("windowsvista"))
# Русифицируем наше приложение
translator = QTranslator()
if (translator.load("qt_ru",
QLibraryInfo.location(QLibraryInfo.TranslationsPath))):
app.installTranslator(translator)
# Если всё хорошо запускаем приложение
window = TreeCard(AllTables('database/objects'), 0)
window.show()
sys.exit(app.exec_())
def main():
# app disexec теперь на pyqt
app = QApplication(sys.argv)
app.setStyle('Fusion')
# Здесь будем работать со стилями(пока в разработке)
#QApplication.setStyle(QStyleFactory.create("windowsvista"))
# Русифицируем наше приложение
translator = QTranslator()
if (translator.load("qt_ru",
QLibraryInfo.location(QLibraryInfo.TranslationsPath))):
app.installTranslator(translator)
# Получим строку подключения к БД
connection = {}
# Если всё хорошо запускаем приложение
window = TdisMainForm(connection)
window.show()
sys.exit(app.exec_())
def run():
"""Run the Gui."""
os.environ["QT_QUICK_CONTROLS_CONF"] = ((
CONF_DIR / "qtquickcontrols2.conf").resolve().as_posix())
app = QApplication(sys.argv)
lang = locale.getdefaultlocale()[0]
lang_file_path = (
(TRANSLATION_DIR /
"jmbde_{lang}.qm".format(lang=lang)).resolve().as_posix())
translator = QTranslator()
translator.load(lang_file_path)
app.installTranslator(translator)
icon_file_path = (IMAGES_DIR / "jmbde.png").resolve().as_posix()
app.setWindowIcon(QIcon(icon_file_path))
main_window = MainWindow(app, translator)
main_window.show()
sys.exit(app.exec_())
def main():
app = QApplication(sys.argv)
app.setWindowIcon(QIcon(':/icons/app.svg'))
fontDB = QFontDatabase()
fontDB.addApplicationFont(':/fonts/Roboto-Regular.ttf')
app.setFont(QFont('Roboto'))
f = QFile(':/style.qss')
f.open(QFile.ReadOnly | QFile.Text)
app.setStyleSheet(QTextStream(f).readAll())
f.close()
translator = QTranslator()
translator.load(':/translations/' + QLocale.system().name() + '.qm')
app.installTranslator(translator)
mw = MainWindow()
mw.show()
sys.exit(app.exec_())
def launch_qt_gui(bk, prefs):
supports_theming = (bk.launcher_version() >= 20200117)
if not ismacos:
setup_highdpi(bk._w.highdpi)
setup_ui_font(bk._w.uifont)
if not ismacos and not iswindows:
# Qt 5.10.1 on Linux resets the global font on first event loop tick.
# So workaround it by setting the font once again in a timer.
QTimer.singleShot(0, lambda: setup_ui_font(bk._w.uifont))
app = QApplication(sys.argv)
icon = os.path.join(bk._w.plugin_dir, bk._w.plugin_name, 'plugin.svg')
app.setWindowIcon(QIcon(icon))
if tuple_version(qVersion()) >= (5, 10, 0):
app.setAttribute(Qt.AA_DisableWindowContextHelpButton)
# Make plugin match Sigil's light/dark theme
if supports_theming:
if bk.colorMode() == "dark":
app.setStyle(QStyleFactory.create("Fusion"))
app.setPalette(dark_palette(bk.color))
print('Application dir: {}'.format(QCoreApplication.applicationDirPath()))
# Install qtbase translator for standard dialogs and such.
# Use the Sigil language setting unless manually overridden.
qt_translator = QTranslator()
if prefs['language_override'] is not None:
print('Plugin preferences language override in effect')
qmf = 'qtbase_{}'.format(prefs['language_override'])
else:
qmf = 'qtbase_{}'.format(bk.sigil_ui_lang)
# Get bundled or external translations directory
qt_trans_dir = getQtTranslationsPath(bk._w.appdir)
print('Qt translation dir: {}'.format(qt_trans_dir))
print('Looking for {} in {}'.format(qmf, qt_trans_dir))
qt_translator.load(qmf, qt_trans_dir)
print('Translator succesfully installed: {}'.format(
app.installTranslator(qt_translator)))
ex = App(bk, prefs)
ex.show()
app.exec_()
return _DETAILS
def launch_gui(bk, prefs):
if not ismacos:
try:
setup_highdpi(bk._w.highdpi)
except Exception:
pass
try:
setup_ui_font(bk._w.uifont)
except Exception:
pass
if not ismacos and not iswindows:
# Qt 5.10.1 on Linux resets the global font on first event loop tick.
# So workaround it by setting the font once again in a timer.
try:
QTimer.singleShot(0, lambda: setup_ui_font(bk._w.uifont))
except Exception:
pass
app = QApplication([])
icon = os.path.join(bk._w.plugin_dir, bk._w.plugin_name, 'plugin.svg')
app.setWindowIcon(QIcon(icon))
if tuple_version(qVersion()) >= (5, 10, 0):
app.setAttribute(Qt.AA_DisableWindowContextHelpButton)
# Make plugin match Sigil's light/dark theme
dark_palette(bk, app)
print('Application dir: {}'.format(QCoreApplication.applicationDirPath()))
# Install qtbase translator for standard dialogs and such.
# Use the Sigil language setting unless manually overridden.
qt_translator = QTranslator()
misc_prefs = prefs['miscellaneous_settings']
if misc_prefs['language_override'] is not None:
print('Plugin preferences language override in effect')
qmf = 'qtbase_{}'.format(misc_prefs['language_override'])
else:
qmf = 'qtbase_{}'.format(bk.sigil_ui_lang)
# Get bundled or external translations directory
qt_trans_dir = getQtTranslationsPath(bk._w.appdir)
print('Qt translation dir: {}'.format(qt_trans_dir))
print('Looking for {} in {}'.format(qmf, qt_trans_dir))
qt_translator.load(qmf, qt_trans_dir)
print('Qt Base Translator succesfully installed: {}'.format(
app.installTranslator(qt_translator)))
# Install translator for the tagmechanic plugin dialog.
# Use the Sigil language setting unless manually overridden.
plugin_translator = QTranslator()
if misc_prefs['language_override'] is not None:
print('Plugin preferences language override in effect')
qmf = '{}_{}'.format(bk._w.plugin_name.lower(),
misc_prefs['language_override'])
else:
qmf = '{}_{}'.format(bk._w.plugin_name.lower(), bk.sigil_ui_lang)
print('Looking for {} in {}'.format(
qmf, os.path.join(bk._w.plugin_dir, bk._w.plugin_name,
'translations')))
plugin_translator.load(
qmf, os.path.join(bk._w.plugin_dir, bk._w.plugin_name, 'translations'))
print('Plugin Translator succesfully installed: {}'.format(
app.installTranslator(plugin_translator)))
win = guiMain(bk, prefs)
app.exec_()
return win.getAbort()
def fedit(data
,result = "list"
,type = "form"
,title = ""
,comment = ""
,icon = None
,parent = None
,apply = None
,ok = True
,cancel = True
,outfile = None
,scrollbar = False
,background_color = None
,widget_color = None
# DJB added
,size = None
,position = None
,style = None
):
"""
Create form dialog and return result
(if Cancel button is pressed, return None)
:param tuple data : datalist, datagroup (see below)
:param str title : form title
:param str comment : header comment
:param QIcon icon : dialog box icon
:param QWidget parent : parent widget
:param str ok : customized ok button label
:param str cancel : customized cancel button label
:param tuple apply : (label, function) customized button label and callback
:param function apply : function taking two arguments (result, widgets)
:param str result : result serialization ('list', 'dict', 'OrderedDict','JSON' or 'XML')
:param str outfile : write result to the file outfile.[py|json|xml]
:param str type : layout type ('form' or 'questions')
:param bool scrollbar : vertical scrollbar
:param str background_color : color of the background
:param str widget_color : color of the widgets
:return: Serialized result (data type depends on `result` parameter)
datalist: list/tuple of (field_name, field_value)
datagroup: list/tuple of (datalist *or* datagroup, title, comment)
Tips:
* one field for each member of a datalist
* one tab for each member of a top-level datagroup
* one page (of a multipage widget, each page can be selected with a
combo box) for each member of a datagroup inside a datagroup
Supported types for field_value:
- int, float, str, unicode, bool
- colors: in Qt-compatible text form, i.e. in hex format or name (red,...)
(automatically detected from a string)
- list/tuple:
* the first element will be the selected index (or value)
* the other elements can be couples (key, value) or only values
"""
# Create a QApplication instance if no instance currently exists
# (e.g. if the module is used directly from the interpreter)
test_travis = os.environ.get('TEST_CI_WIDGETS', None)
if test_travis is not None:
app = QApplication.instance()
if app is None:
app = QApplication([])
timer = QTimer(app)
timer.timeout.connect(app.quit)
timer.start(1000)
elif QApplication.startingUp():
_app = QApplication([])
translator_qt = QTranslator()
translator_qt.load('qt_' + QLocale.system().name(),QLibraryInfo.location(QLibraryInfo.TranslationsPath))
_app.installTranslator(translator_qt)
serial = ['list', 'dict', 'OrderedDict', 'JSON', 'XML']
if result not in serial:
print(f"Warning: '{result}' not in {', '.join(serial)}, default to list", file=sys.stderr)
result = 'list'
layouts = ['form', 'questions']
if type not in layouts:
print(f"Warning: '{type}' not in {', '.join(layouts)}, default to form", file=sys.stderr)
type = 'form'
dialog = FormDialog(data, title, comment, icon, parent, apply, ok, cancel, result, outfile, type, scrollbar, background_color, widget_color)
# djb added
if size is not None:
dialog.resize(size[0],size[1])
if position is not None:
dialog.move(position[0],position[1])
if style is not None:
dialog.setStyleSheet(style)
if dialog.exec_():
return dialog.get()
class LearnBlock(QMainWindow):
def __init__(self):
self.app = QApplication(sys.argv)
QMainWindow.__init__(self)
self.ui = Learnblock.Ui_MainWindow()
self.configs = {}
self.ui.setupUi(self)
self.language = Language()
# Load Translators
self.initTranslators()
self.changeLanguage()
self._view = View(None, self.ui.frame)
self._view.setObjectName("view")
self.ui.verticalLayout_3.addWidget(self._view)
self._scene = Scene(self, self._view)
self._view.setScene(self._scene)
self._view.show()
self._view.setZoom(False)
self._view.setScene(self._scene)
self._view.show()
self._view.setZoom(False)
# Parser
self._parserblocks = ParserBlocks()
# Connect UI
self.ui.language.currentIndexChanged.connect(self.changeLanguage)
self.ui.splitter.splitterMoved.connect(self.resizeFunctionTab)
self.translations = AllTranslations()
self.translations.updated.connect(self.saveConfig)
self.ui.block2textpushButton.clicked.connect(self.blocksToText)
self.ui.addWhenpushButton.clicked.connect(self.addWhen)
self.showMaximized()
self.initBlocks()
self.language.changed.emit("en")
self.add_when_gui = AddWhenGui()
self.add_when_gui.ui.pushButtonOK.clicked.connect(self.retaddWhen)
self.add_when_gui.ui.pushButtonCancel.clicked.connect(self.retaddWhen)
r = self.app.exec_()
sys.exit(r)
@Slot()
def saveConfig(self):
for file, v in self.configs.items():
with open(file, 'w') as fp:
json.dump(v, fp, sort_keys=True, indent=4)
@property
def scene(self):
return self._scene
@Slot()
def resizeFunctionTab(self):
self.pre_sizes = self.ui.splitter.sizes()
width = self.ui.functions.width() - 51
tables = list(self.dicTables.values()) + [self.ui.tableSearch]
for v in tables:
v.setColumnWidth(0, width - 20)
@Slot()
def addWhen(self):
self.add_when_gui.open()
def retaddWhen(self):
button = self.sender()
if button is self.add_when_gui.ui.pushButtonOK:
block = self.add_when_gui.block
item = QGraphicsBlockItem.fromBlock(block, "when",
self.add_when_gui.translations,
self.add_when_gui.getConfig())
# item = QGraphicsBlockItem(_parent=None, _imgfile=self.tmpFile, _functionname=self._functionmame,
# _translations=self._translations, _vars=copy.copy(self._Variables),
# _connections=self._connections_conf, _type=self._type,
# _typeIMG=self._typeImg)
self.scene.addItem(item=item)
else:
self.add_when_gui.close()
def initTranslators(self):
combobox = self.ui.language
combobox.clear()
for file in os.listdir(PATHLANGUAGES):
if os.path.splitext(file)[1] == ".qm":
translator = QTranslator()
print('Localization loaded: ',
os.path.join(PATHLANGUAGES, file),
translator.load(file, PATHLANGUAGES))
qttranslator = QTranslator()
print(
'Localization loaded: ',
os.path.join(
QLibraryInfo.location(QLibraryInfo.TranslationsPath),
"q" + file),
qttranslator.load(
"q" + file,
QLibraryInfo.location(QLibraryInfo.TranslationsPath)))
combobox.addItem(file[2:-3],
(translator, qttranslator, file[2:-3]))
for l in sorted(LANGUAGES):
combobox.addItem(l, (translator, qttranslator, l))
def initBlocks(self):
self.dicTables = {
BlockType.CONTROL: self.ui.tableControl,
BlockType.MOTOR: self.ui.tableMotor,
BlockType.PERCEPTUAL: self.ui.tablePerceptual,
BlockType.PROPIOPERCEPTIVE: self.ui.tablePropioperceptive,
BlockType.OPERATOR: self.ui.tableOperadores,
BlockType.VARIABLE: self.ui.tableVariables,
BlockType.USERFUNCTION: self.ui.tableUserfunctions,
BlockType.EXPRESS: self.ui.tableExpress,
BlockType.OTHERS: self.ui.tableOthers
}
for table in iter(self.dicTables.values()):
table.verticalHeader().setVisible(False)
table.horizontalHeader().setVisible(False)
table.setColumnCount(1)
table.setRowCount(0)
self.configs = load_blocks_Config()
for blocks in self.configs.values():
for b in blocks:
_type = BlockType.fromString(b["type"])
table = self.dicTables[_type]
for _img in b["img"]:
table.insertRow(table.rowCount())
b.setdefault("variables", [])
b.setdefault("languages", {"EN": b["name"]})
b.setdefault("tooltip", b["languages"])
button = ButtonBlock(self,
_table=table,
_row=table.rowCount() - 1,
_imgfileconf=_img,
_functionmame=b["name"],
_translations=b["languages"],
_tooltips=b["tooltip"],
_vars=b["variables"],
_type=_type)
table.setCellWidget(table.rowCount() - 1, 0, button)
@Slot()
def changeLanguage(self):
translator, qttranslator, language = self.ui.language.currentData()
self.app.installTranslator(translator)
self.app.installTranslator(qttranslator)
self.ui.retranslateUi(self)
self.language.language = language
def blocksToText(self):
name_Client = self.ui.clientscomboBox.currentText()
self.blocksToTextCode()
self.TBlocCodeToPython(name_Client)
def TBlocCodeToPython(self, name_Client):
textCode = self.ui.textCode.toPlainText()
try:
code = parserfromTBlockCode(textCode, name_Client)
if not code:
msgBox = QMessageBox()
msgBox.setWindowTitle(self.tr("Warning"))
msgBox.setIcon(QMessageBox.Warning)
msgBox.setText(self.tr("Your code is empty or is not correct"))
msgBox.setStandardButtons(QMessageBox.Ok)
msgBox.setDefaultButton(QMessageBox.Ok)
msgBox.exec_()
self.ui.pythonCode.clear()
self.ui.pythonCode.setText(code)
return code
except ParseException as e:
traceback.print_exc()
msgBox = QMessageBox()
msgBox.setWindowTitle(self.tr("Warning"))
msgBox.setIcon(QMessageBox.Warning)
msgBox.setText(
self.tr("line: {}".format(e.line) + "\n " + " " * e.col +
"^"))
msgBox.setStandardButtons(QMessageBox.Ok)
msgBox.setDefaultButton(QMessageBox.Ok)
msgBox.exec_()
except Exception as e:
msgBox = QMessageBox()
msgBox.setWindowTitle(self.tr("Warning"))
msgBox.setIcon(QMessageBox.Warning)
msgBox.setText(e)
msgBox.setStandardButtons(QMessageBox.Ok)
msgBox.setDefaultButton(QMessageBox.Ok)
msgBox.exec_()
return False
def blocksToTextCode(self):
text = ""
# for library in self.listLibrary: # TODO add variables
# text = 'import "' + library[0] + '"\n'
# if len(self.listNameVars) > 0:
# for name in self.listNameVars:
# text += name + " = None\n"
blocks = self.scene.getListInstructions()
code = self._parserblocks.parserBlocks(blocks)
self.ui.textCode.clear()
self.ui.textCode.setText(text + code)
def main():
if parser.lang:
sys_locale = parser.lang[0]
else:
sys_locale = QtCore.QLocale.system().name()
translator = QtCore.QTranslator()
#load intern dialogs translations
qtTranslator = QtCore.QTranslator()
qtTranslator.load("qt_" + sys_locale, QtCore.QLibraryInfo.location(QtCore.QLibraryInfo.TranslationsPath))
#load translations files
translations_path = os.path.join(os.getenv("PINGUINO_LIB"), "multilanguage")
trasnlations = os.path.exists(translations_path)
if trasnlations and (os.getenv("PINGUINO_MODE") == "NORMAL"):
translations_file = "pinguino_" + sys_locale
if translations_file + ".qm" in os.listdir(translations_path):
translator.load(os.path.join(os.getenv("PINGUINO_LIB"), "multilanguage", "pinguino_{}.qm".format(sys_locale)))
elif "_" in sys_locale:
sys_locale = sys_locale[:sys_locale.find("_")]
translations_file = "pinguino_" + sys_locale
if translations_file + ".qm" in os.listdir(translations_path):
translator.load(os.path.join(os.getenv("PINGUINO_LIB"), "multilanguage", "pinguino_{}.qm".format(sys_locale)))
app = QApplication(sys.argv)
#Splash (pinguino\qtgui\resources\art)
#pixmap = QPixmap(":/logo/art/splash.png")
pixmap = QPixmap("pinguino/qtgui/resources/art/splash.png")
#pixmap = QPixmap("pinguino/qtgui/resources/art/pinguino_logo_background_blue-256x256.png")
#pixmap = QPixmap(760, 256)
#pixmap.fill(QtGui.QColor("#4d4d4d"))
# keep the splash screen above all the other windows on the desktop
splash = QSplashScreen(pixmap, QtCore.Qt.WindowStaysOnTopHint)
splash.show()
splash.setStyleSheet("""
font-family: inherit;
font-weight: normal;
font-size: 11pt;
""")
# update the splash screen with messages
def splash_write(msg):
if not splash is None:
splash.showMessage("\t" + msg, color=QtGui.QColor("#4d4d4d"), alignment=QtCore.Qt.AlignBottom)
splash_write(NAME + " " + MAJOR)
app.processEvents()
app.installTranslator(qtTranslator)
if trasnlations:
app.installTranslator(translator)
frame = PinguinoIDE(splash_write=splash_write)
frame.show()
if not splash is None:
splash.finish(frame)
app.exec_()
class Application:
def __init__(self):
self.title = u'Tracks detection'
# Настройки
self.settings = Settings()
def application_init(self):
'''Инициализация Qt приложения'''
# Создание приложение
self.qapp = QApplication(sys.argv)
self.__app_working_status = True
# Установка локлизатора
translator = QTranslator(self.qapp)
translator.load('lang/tr_ru', os.path.dirname(__file__))
self.qapp.installTranslator(translator)
self.mainDialog = MainDialog(self, self.title)
self.mainDialog.closeApp.connect(self.__finalize_before_quit)
self.controls = {
'step': ['X', 'Y', 'Z', 'A'],
'servo': ['B', 'C'],
'pins': {
'P1': [],
'P2': ['UV', 'VIS']
}
}
self.mainDialog.show()
self.project_init()
self.gui_init()
self.communication_init()
sys.exit(self.qapp.exec_())
def __finalize_before_quit(self):
self.__app_working_status = False
if self.grbl.connection: self.grbl.connection.close()
if self.communication_thread: self.communication_thread.join()
self.qapp.exit()
def retuenicon(self, name):
return QIcon(
QPixmap(
os.path.normpath(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'', name + '.png'))))
def project_init(self):
self.project = Project('New')
def async_sleep(self, sleep):
for i in range(sleep):
time.sleep(1)
if not self.__app_working_status: break
def __connection_worker(self):
while self.__app_working_status:
status = self.__current_conacion_procedure()
if status: break
if status:
self.__current_conacion_procedure = self.grbl.getStatus
else:
self.__current_conacion_procedure = self.__auto_seach__
self.async_sleep(5)
self.cnc_indicator.setStatus(status)
def communication_init(self):
self.grbl = GRBL(HOST=self.settings.grblip)
self.__current_conacion_procedure = self.__auto_seach__
self.communication_thread = threading.Thread(
target=self.__connection_worker)
self.communication_thread.setDaemon(True)
self.communication_thread.start()
def gui_init(self):
pref_menu = menu_item(u'Preferences')
ref_menu = menu_item(u'Reference')
gen_menu = menu_item(u'Device')
gen_menu.addChildren(menu_item(u'GRBL', self.showGrblDialog))
file_menu = menu_item(self.qapp.tr(u'File'))
file_menu.addChildren(menu_item(u'New', self.newProject),
menu_item(u'Open', self.openProject),
menu_item(u'Import...', self.openFile),
menu_item(u'Save', self.saveProject),
menu_item(u'Exit', self.qapp.exit))
pref_menu.addChildren(gen_menu, menu_item(u'Settings'))
ref_menu.addChildren(menu_item(u'Help'),
menu_item(u'About', self.showAbout))
self.mainDialog.addMenuItems(file_menu, pref_menu, ref_menu)
self.cnc_indicator = work_indicator(u'CNC')
self.mainDialog.addStatusObj(self.cnc_indicator)
self.progressBar = QProgressBar()
self.progressBar.setTextVisible(True)
self.progressBar.setAlignment(Qt.AlignCenter)
self.progressBar.minimum = 1
self.progressBar.maximum = 100
self.mainDialog.addPermanentStatusObj(self.progressBar)
'''Инициализациия таблицы содержания'''
treeDock = QDockWidget(self.qapp.tr(u'Project tree'), self.mainDialog)
treeDock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.mainDialog.addDockWidget(Qt.LeftDockWidgetArea, treeDock)
self.mainnodes = [Node("Samples"), Node("Other")]
self.project_tree = ProjectTree(self, self.mainnodes)
self.project_tree.doubleClicked.connect(self.on_tree_clicked)
treeDock.setWidget(self.project_tree)
'''Инициализациия центра'''
jog = JogWidget(app=self.qapp,
axies=self.controls,
pinAcions=self.pinAcions,
motorActions=self.send_to_grbl)
self.mainDialog.addToCenter(jog)
jog.raise_()
def send_to_grbl(self, text, send_type):
if len(text):
self.grbl.send_task(text, send_type)
def pinAcions(self, status, pin):
task = 'M62 {pin}'.format(pin=pin) if status else 'M63 {pin}'.format(
pin=pin)
self.grbl.send_task(task, SENDTYPE.IDLE)
def setProgress(self, step, steps):
value = step / float(len(steps)) * 100.
indx = int(ceil(step - 1))
text = self.qapp.tr(steps[indx])
self.progressBar.setFormat("{0} - {1}%".format(text, round(value, 0)))
self.progressBar.setValue(value)
self.qapp.processEvents()
def on_tree_clicked(self, index):
item = self.project_tree.selectedIndexes()[0]
if self.project.current_sample != item.model().itemFromIndex(
index).obj:
self.project.current_sample = item.model().itemFromIndex(index).obj
self.refresh()
def newProject(self):
self.mainDialog.PreparedArea.clear()
self.mainDialog.ThroughArea.clear()
self.mainDialog.BacklightArea.clear()
self.mainnodes = [Node("Samples"), Node("Other")]
self.project_tree.setMainNodes(self.mainnodes)
self.project = Project('TEMP')
self.refresh()
def openProject(self):
fileName, _ = QFileDialog.getOpenFileName(
self.mainDialog, self.qapp.tr("Load project"), ".\\",
self.qapp.tr("Project file (*.tpr)"))
infile = open(fileName, 'rb')
self.project = pickle.load(infile)
infile.close()
self.mainDialog.PreparedArea.clear()
self.mainDialog.ThroughArea.clear()
self.mainDialog.BacklightArea.clear()
self.mainnodes = [Node("Samples"), Node("Other")]
self.project_tree.setMainNodes(self.mainnodes)
self.refresh()
def saveProject(self):
fileName, _ = QFileDialog.getSaveFileName(
self.mainDialog, self.qapp.tr("Save project"), ".\\",
self.qapp.tr("Project file (*.tpr)"))
outfile = open(fileName, "wb")
pickle.dump(self.project, outfile)
outfile.close()
def draw_tree(self):
target = self.mainnodes[0]
children = target.children()
samples_in_tree = []
for sample in self.project.samples.get_sorted_by_id():
if len(children) > 0:
samples_in_tree = [node.obj for node in children]
if sample not in samples_in_tree:
target.addChild(Node(sample))
self.project_tree.refresh()
def openFile(self):
path_to_file, _ = QFileDialog.getOpenFileName(
self.mainDialog, self.qapp.tr("Load Image"),
self.qapp.tr(u".\example_imgs"), self.qapp.tr("Images (*.jpg)"))
# path_to_file, _ = QFileDialog.getOpenFileName(self.mainDialog, self.app.tr("Load Image"), self.app.tr("~/Desktop/"), self.app.tr("Images (*.jpg)"))
# Определяем тип файла на просвет или на подсветку
tools.processing(path_to_file, self.project, self.separator,
self.segmentation, self.counter, self.setProgress)
self.refresh()
def refresh(self):
self.draw_tree()
self.fill_table()
self.updete_viewers()
def fill_table(self):
data = []
sample = self.project.current_sample
if not sample:
data = [['', '', '']]
self.mainDialog.tablemodel.setData(data)
return
for track in sample.tracks.get_sorted():
data.append([str(track.id), str(track.count), str(track.area)])
self.mainDialog.tablemodel.setData(data)
self.mainDialog.table.resizeRowsToContents()
self.mainDialog.table.resizeColumnsToContents()
count = round(
np.sum([track.count
for track in sample.tracks.get_sorted_by_id()]), 2)
general_area = round(
np.sum([track.area for track in sample.tracks.get_sorted_by_id()]),
2)
self.mainDialog.infolabel.setText('''
<p align="center">General tracks count<br>{tracks_count}</p>
<p align="center">General tracks area (%)<br>{general_area}</p>
'''.format(tracks_count=count,
general_area=general_area))
def draw_objects(self, viewer, sample):
for track in sample.tracks.get_sorted():
viewer.add_rect(track.left, track.rigth, track.top, track.bottom)
viewer.add_Polygon(track.contour, track.left, track.top)
text = 'Count: {tracks_count}\nArea (%): {general_area}'.format(
tracks_count=track.count, general_area=track.area)
viewer.add_Text(text, track.left, track.top)
def updete_viewers(self):
sample = self.project.current_sample
if not sample:
return
self.mainDialog.ThroughArea.load_image(sample.through)
self.mainDialog.BacklightArea.load_image(sample.backlight)
self.mainDialog.PreparedArea.load_image(sample.prepared)
self.draw_objects(self.mainDialog.ThroughArea, sample)
self.draw_objects(self.mainDialog.BacklightArea, sample)
self.draw_objects(self.mainDialog.PreparedArea, sample)
def __connect_to_grbl__(self):
'''Функция подключения к CNC сканера, которая передается в настройки станка'''
status = self.grbl.connect()
if not status: return
self.cnc_indicator.setStatus(-1)
self.grbl.reset_alarm()
self.cnc_indicator.setStatus(status)
return status
def __check_ip__(self, ip):
status = False
test_grbl = GRBL(HOST=self.settings.grblip)
test_grbl.setHost(ip)
try:
status = test_grbl.connect(check=False)
test_grbl.connection.close()
except OSError:
pass
return ip if status else None
def __auto_seach__(self, property=None):
'''Функция авто поиска IP станка
property нужен, чтобы вернуть результат в inputField окна настроек
'''
if self.grbl.connection: self.grbl.connection.close()
devices = [device for device in os.popen('arp -a')]
ip_candidates = [
re.findall(r"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b", device)[0]
for device in devices if
len(re.findall(r"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b",
device)) != 0
]
if self.settings.grblip in ip_candidates:
ip_candidates.remove(self.settings.grblip)
ip_candidates.insert(0, self.settings.grblip)
pool = ThreadPool(4)
results = pool.map(self.__check_ip__, ip_candidates)
index = np.where(results != None)[0][0]
if not results[index]:
# print(self.qapp.tr('There is not devices in current net'))
return
pool.close()
pool.join()
self.grbl.setHost(results[index])
self.__connect_to_grbl__()
if property:
property.setText(
results[index]
) # property нужен, чтобы вернуть результат в inputField
self.settings.grblip = results[index]
self.settings.write()
print(self.qapp.tr('Connected to') + ' {ip}'.format(ip=results[index]))
return True
def showAbout(self):
about = about_dialog(self)
about.open()
def showGrblDialog(self):
dialog = grblDialog(self,
connection_func=self.__connect_to_grbl__,
auto_seach_func=self.__auto_seach__)
dialog.execute(self.settings)
if not file.open(QFile.ReadOnly | QFile.Text):
QMessageBox.warning(self, "Cryptix",
f"Cannot read {fileName} :\n{file.errorString()}")
return
stream = QTextStream(file)
self.encryptEdit.setPlainText(stream.readAll())
self.statusBar().showMessage("File loaded", 2000)
if __name__ == '__main__':
import sys
app = QApplication(sys.argv)
french = QTranslator()
if french.load("fr_fr", "translations"):
app.installTranslator(french)
main = MainWindow()
main.show()
# wid = QComboBox()
# for method in dir(wid):
# if '__' not in method: print(method)
# print(title)
# print("Cryptix Version 0.3.0")
# print("----------------------------------------\n")
sys.exit(app.exec_())
size = self.geometry()
self.move((screen_size.width() - size.width()) / 2, \
(screen_size.height() - size.height()) / 2)
class MakeSoundThread(QThread):
def run(self):
while True:
beep(500, 3)
self.sleep(10)
if self.isInterruptionRequested():
return
if __name__ == '__main__':
import timer_rc
app = QApplication(sys.argv)
# 先自动加载最佳语言方案
default_translator = QTranslator()
default_translator.load(f':/translations/timer_{QLocale.system().name()}')
app.installTranslator(default_translator)
timer = Timer(app)
timer.show()
sys.exit(app.exec_())
def setup_language(app: QApplication):
lang = "lang"
trans = QTranslator(app)
trans.load(os.path.join(QGRAIN_ROOT_PATH, "assets", lang))
app.installTranslator(trans)
if __name__ == '__main__':
app = QApplication(sys.argv)
os.environ["QT_QUICK_CONTROLS_STYLE"] = "Material"
global language
try:
fichier = open("resources\language.txt", "r")
language = (fichier.read())
print(language)
if language == "french":
translator = QTranslator(app)
translator.load('resources/french', os.path.dirname(__file__))
app.installTranslator(translator)
else:
None
fichier.close()
except:
None
engine = QQmlApplicationEngine()
engine.load("qml/ArduinoExao.qml")
win = engine.rootObjects()[0]
ctx = engine.rootContext()
py_mainapp = MainApp(ctx, win)
ctx.setContextProperty("py_MainApp", py_mainapp)
# Command line: Language list
if parser.isSet(languageListOption):
sys.exit(showLanguageList())
# Command line: Language
language = parser.value(languageOption)
#
# Translations
locale = QLocale(language) if language else QLocale.system()
translator = QTranslator()
if translator.load(locale, None, None, ":/translations"):
app.installTranslator(translator)
translatorQtBase = QTranslator()
if translatorQtBase.load(
locale, "qtbase", "_",
QLibraryInfo.location(QLibraryInfo.TranslationsPath)):
app.installTranslator(translatorQtBase)
window = MainWindow()
fileNames = parser.positionalArguments()
for fileName in fileNames:
window.openDocument(fileName)
window.show()
sys.exit(app.exec_())
