402 lines
17 KiB
Python
402 lines
17 KiB
Python
import sys
|
|
|
|
from PyQt5 import QtWidgets
|
|
from PyQt5.QtCore import QSettings
|
|
|
|
from appGUI.GUIElements import RadioSet, FCSpinner, FCCheckBox, FCComboBox, FCButton, OptionalInputSection, \
|
|
FCDoubleSpinner
|
|
from appGUI.preferences.OptionsGroupUI import OptionsGroupUI
|
|
|
|
import gettext
|
|
import appTranslation as fcTranslate
|
|
import builtins
|
|
|
|
fcTranslate.apply_language('strings')
|
|
if '_' not in builtins.__dict__:
|
|
_ = gettext.gettext
|
|
|
|
settings = QSettings("Open Source", "FlatCAM")
|
|
if settings.contains("machinist"):
|
|
machinist_setting = settings.value('machinist', type=int)
|
|
else:
|
|
machinist_setting = 0
|
|
|
|
|
|
class GeneralAppPrefGroupUI(OptionsGroupUI):
|
|
def __init__(self, decimals=4, parent=None):
|
|
super(GeneralAppPrefGroupUI, self).__init__(self, parent=parent)
|
|
|
|
self.setTitle(_("App Preferences"))
|
|
self.decimals = decimals
|
|
|
|
# Create a form layout for the Application general settings
|
|
grid0 = QtWidgets.QGridLayout()
|
|
self.layout.addLayout(grid0)
|
|
grid0.setColumnStretch(0, 0)
|
|
grid0.setColumnStretch(1, 1)
|
|
|
|
# Units for FlatCAM
|
|
self.unitslabel = QtWidgets.QLabel('<span style="color:red;"><b>%s:</b></span>' % _('Units'))
|
|
self.unitslabel.setToolTip(_("The default value for FlatCAM units.\n"
|
|
"Whatever is selected here is set every time\n"
|
|
"FlatCAM is started."))
|
|
self.units_radio = RadioSet([{'label': _('MM'), 'value': 'MM'},
|
|
{'label': _('IN'), 'value': 'IN'}])
|
|
|
|
grid0.addWidget(self.unitslabel, 0, 0)
|
|
grid0.addWidget(self.units_radio, 0, 1)
|
|
|
|
# Precision Metric
|
|
self.precision_metric_label = QtWidgets.QLabel('%s:' % _('Precision MM'))
|
|
self.precision_metric_label.setToolTip(
|
|
_("The number of decimals used throughout the application\n"
|
|
"when the set units are in METRIC system.\n"
|
|
"Any change here require an application restart.")
|
|
)
|
|
self.precision_metric_entry = FCSpinner()
|
|
self.precision_metric_entry.set_range(2, 16)
|
|
self.precision_metric_entry.setWrapping(True)
|
|
|
|
grid0.addWidget(self.precision_metric_label, 1, 0)
|
|
grid0.addWidget(self.precision_metric_entry, 1, 1)
|
|
|
|
# Precision Inch
|
|
self.precision_inch_label = QtWidgets.QLabel('%s:' % _('Precision Inch'))
|
|
self.precision_inch_label.setToolTip(
|
|
_("The number of decimals used throughout the application\n"
|
|
"when the set units are in INCH system.\n"
|
|
"Any change here require an application restart.")
|
|
)
|
|
self.precision_inch_entry = FCSpinner()
|
|
self.precision_inch_entry.set_range(2, 16)
|
|
self.precision_inch_entry.setWrapping(True)
|
|
|
|
grid0.addWidget(self.precision_inch_label, 2, 0)
|
|
grid0.addWidget(self.precision_inch_entry, 2, 1)
|
|
|
|
# Graphic Engine for FlatCAM
|
|
self.ge_label = QtWidgets.QLabel('<b>%s:</b>' % _('Graphic Engine'))
|
|
self.ge_label.setToolTip(_("Choose what graphic engine to use in FlatCAM.\n"
|
|
"Legacy(2D) -> reduced functionality, slow performance but enhanced compatibility.\n"
|
|
"OpenGL(3D) -> full functionality, high performance\n"
|
|
"Some graphic cards are too old and do not work in OpenGL(3D) mode, like:\n"
|
|
"Intel HD3000 or older. In this case the plot area will be black therefore\n"
|
|
"use the Legacy(2D) mode."))
|
|
self.ge_radio = RadioSet([{'label': _('Legacy(2D)'), 'value': '2D'},
|
|
{'label': _('OpenGL(3D)'), 'value': '3D'}],
|
|
orientation='vertical')
|
|
|
|
grid0.addWidget(self.ge_label, 3, 0)
|
|
grid0.addWidget(self.ge_radio, 3, 1)
|
|
|
|
separator_line = QtWidgets.QFrame()
|
|
separator_line.setFrameShape(QtWidgets.QFrame.HLine)
|
|
separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
|
|
grid0.addWidget(separator_line, 4, 0, 1, 2)
|
|
|
|
# Application Level for FlatCAM
|
|
self.app_level_label = QtWidgets.QLabel('<span style="color:red;"><b>%s:</b></span>' % _('APPLICATION LEVEL'))
|
|
self.app_level_label.setToolTip(_("Choose the default level of usage for FlatCAM.\n"
|
|
"BASIC level -> reduced functionality, best for beginner's.\n"
|
|
"ADVANCED level -> full functionality.\n\n"
|
|
"The choice here will influence the parameters in\n"
|
|
"the Selected Tab for all kinds of FlatCAM objects."))
|
|
self.app_level_radio = RadioSet([{'label': _('Basic'), 'value': 'b'},
|
|
{'label': _('Advanced'), 'value': 'a'}])
|
|
|
|
grid0.addWidget(self.app_level_label, 5, 0, 1, 2)
|
|
grid0.addWidget(self.app_level_radio, 6, 0, 1, 2)
|
|
|
|
# Portability for FlatCAM
|
|
self.portability_cb = FCCheckBox('%s' % _('Portable app'))
|
|
self.portability_cb.setToolTip(_("Choose if the application should run as portable.\n\n"
|
|
"If Checked the application will run portable,\n"
|
|
"which means that the preferences files will be saved\n"
|
|
"in the application folder, in the lib\\config subfolder."))
|
|
|
|
grid0.addWidget(self.portability_cb, 7, 0, 1, 2)
|
|
|
|
separator_line = QtWidgets.QFrame()
|
|
separator_line.setFrameShape(QtWidgets.QFrame.HLine)
|
|
separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
|
|
grid0.addWidget(separator_line, 8, 0, 1, 2)
|
|
|
|
# Languages for FlatCAM
|
|
self.languagelabel = QtWidgets.QLabel('<b>%s</b>' % _('Languages'))
|
|
self.languagelabel.setToolTip(_("Set the language used throughout FlatCAM."))
|
|
self.language_cb = FCComboBox()
|
|
|
|
grid0.addWidget(self.languagelabel, 9, 0, 1, 2)
|
|
grid0.addWidget(self.language_cb, 10, 0, 1, 2)
|
|
|
|
self.language_apply_btn = FCButton(_("Apply Language"))
|
|
self.language_apply_btn.setToolTip(_("Set the language used throughout FlatCAM.\n"
|
|
"The app will restart after click."))
|
|
|
|
grid0.addWidget(self.language_apply_btn, 15, 0, 1, 2)
|
|
|
|
separator_line = QtWidgets.QFrame()
|
|
separator_line.setFrameShape(QtWidgets.QFrame.HLine)
|
|
separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
|
|
grid0.addWidget(separator_line, 16, 0, 1, 2)
|
|
|
|
# -----------------------------------------------------------
|
|
# ----------- APPLICATION STARTUP SETTINGS ------------------
|
|
# -----------------------------------------------------------
|
|
|
|
self.startup_label = QtWidgets.QLabel('<b>%s</b>' % _('Startup Settings'))
|
|
grid0.addWidget(self.startup_label, 17, 0, 1, 2)
|
|
|
|
# Splash Screen
|
|
self.splash_cb = FCCheckBox('%s' % _('Splash Screen'))
|
|
self.splash_cb.setToolTip(
|
|
_("Enable display of the splash screen at application startup.")
|
|
)
|
|
|
|
qsettings = QSettings("Open Source", "FlatCAM")
|
|
if qsettings.value("splash_screen"):
|
|
self.splash_cb.set_value(True)
|
|
else:
|
|
self.splash_cb.set_value(False)
|
|
|
|
grid0.addWidget(self.splash_cb, 18, 0, 1, 2)
|
|
|
|
# Sys Tray Icon
|
|
self.systray_cb = FCCheckBox('%s' % _('Sys Tray Icon'))
|
|
self.systray_cb.setToolTip(
|
|
_("Enable display of FlatCAM icon in Sys Tray.")
|
|
)
|
|
grid0.addWidget(self.systray_cb, 19, 0, 1, 2)
|
|
|
|
# Shell StartUp CB
|
|
self.shell_startup_cb = FCCheckBox(label='%s' % _('Show Shell'))
|
|
self.shell_startup_cb.setToolTip(
|
|
_("Check this box if you want the shell to\n"
|
|
"start automatically at startup.")
|
|
)
|
|
|
|
grid0.addWidget(self.shell_startup_cb, 20, 0, 1, 2)
|
|
|
|
# Project at StartUp CB
|
|
self.project_startup_cb = FCCheckBox(label='%s' % _('Show Project'))
|
|
self.project_startup_cb.setToolTip(
|
|
_("Check this box if you want the project/selected/tool tab area to\n"
|
|
"to be shown automatically at startup.")
|
|
)
|
|
grid0.addWidget(self.project_startup_cb, 21, 0, 1, 2)
|
|
|
|
# Version Check CB
|
|
self.version_check_cb = FCCheckBox(label='%s' % _('Version Check'))
|
|
self.version_check_cb.setToolTip(
|
|
_("Check this box if you want to check\n"
|
|
"for a new version automatically at startup.")
|
|
)
|
|
|
|
grid0.addWidget(self.version_check_cb, 22, 0, 1, 2)
|
|
|
|
# Send Stats CB
|
|
self.send_stats_cb = FCCheckBox(label='%s' % _('Send Statistics'))
|
|
self.send_stats_cb.setToolTip(
|
|
_("Check this box if you agree to send anonymous\n"
|
|
"stats automatically at startup, to help improve FlatCAM.")
|
|
)
|
|
|
|
grid0.addWidget(self.send_stats_cb, 23, 0, 1, 2)
|
|
|
|
self.ois_version_check = OptionalInputSection(self.version_check_cb, [self.send_stats_cb])
|
|
|
|
separator_line = QtWidgets.QFrame()
|
|
separator_line.setFrameShape(QtWidgets.QFrame.HLine)
|
|
separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
|
|
grid0.addWidget(separator_line, 24, 0, 1, 2)
|
|
|
|
# Worker Numbers
|
|
self.worker_number_label = QtWidgets.QLabel('%s:' % _('Workers number'))
|
|
self.worker_number_label.setToolTip(
|
|
_("The number of Qthreads made available to the App.\n"
|
|
"A bigger number may finish the jobs more quickly but\n"
|
|
"depending on your computer speed, may make the App\n"
|
|
"unresponsive. Can have a value between 2 and 16.\n"
|
|
"Default value is 2.\n"
|
|
"After change, it will be applied at next App start.")
|
|
)
|
|
self.worker_number_sb = FCSpinner()
|
|
self.worker_number_sb.set_range(2, 16)
|
|
|
|
grid0.addWidget(self.worker_number_label, 25, 0)
|
|
grid0.addWidget(self.worker_number_sb, 25, 1)
|
|
|
|
# Geometric tolerance
|
|
tol_label = QtWidgets.QLabel('%s:' % _("Geo Tolerance"))
|
|
tol_label.setToolTip(_(
|
|
"This value can counter the effect of the Circle Steps\n"
|
|
"parameter. Default value is 0.005.\n"
|
|
"A lower value will increase the detail both in image\n"
|
|
"and in Gcode for the circles, with a higher cost in\n"
|
|
"performance. Higher value will provide more\n"
|
|
"performance at the expense of level of detail."
|
|
))
|
|
self.tol_entry = FCDoubleSpinner()
|
|
self.tol_entry.setSingleStep(0.001)
|
|
self.tol_entry.set_precision(6)
|
|
|
|
grid0.addWidget(tol_label, 26, 0)
|
|
grid0.addWidget(self.tol_entry, 26, 1)
|
|
|
|
separator_line = QtWidgets.QFrame()
|
|
separator_line.setFrameShape(QtWidgets.QFrame.HLine)
|
|
separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
|
|
grid0.addWidget(separator_line, 27, 0, 1, 2)
|
|
|
|
# Save Settings
|
|
self.save_label = QtWidgets.QLabel('<b>%s</b>' % _("Save Settings"))
|
|
grid0.addWidget(self.save_label, 28, 0, 1, 2)
|
|
|
|
# Save compressed project CB
|
|
self.save_type_cb = FCCheckBox(_('Save Compressed Project'))
|
|
self.save_type_cb.setToolTip(
|
|
_("Whether to save a compressed or uncompressed project.\n"
|
|
"When checked it will save a compressed FlatCAM project.")
|
|
)
|
|
|
|
grid0.addWidget(self.save_type_cb, 29, 0, 1, 2)
|
|
|
|
# Project LZMA Comppression Level
|
|
self.compress_spinner = FCSpinner()
|
|
self.compress_spinner.set_range(0, 9)
|
|
self.compress_label = QtWidgets.QLabel('%s:' % _('Compression'))
|
|
self.compress_label.setToolTip(
|
|
_("The level of compression used when saving\n"
|
|
"a FlatCAM project. Higher value means better compression\n"
|
|
"but require more RAM usage and more processing time.")
|
|
)
|
|
|
|
grid0.addWidget(self.compress_label, 30, 0)
|
|
grid0.addWidget(self.compress_spinner, 30, 1)
|
|
|
|
self.proj_ois = OptionalInputSection(self.save_type_cb, [self.compress_label, self.compress_spinner], True)
|
|
|
|
# Auto save CB
|
|
self.autosave_cb = FCCheckBox(_('Enable Auto Save'))
|
|
self.autosave_cb.setToolTip(
|
|
_("Check to enable the autosave feature.\n"
|
|
"When enabled, the application will try to save a project\n"
|
|
"at the set interval.")
|
|
)
|
|
|
|
grid0.addWidget(self.autosave_cb, 31, 0, 1, 2)
|
|
|
|
# Auto Save Timeout Interval
|
|
self.autosave_entry = FCSpinner()
|
|
self.autosave_entry.set_range(0, 9999999)
|
|
self.autosave_label = QtWidgets.QLabel('%s:' % _('Interval'))
|
|
self.autosave_label.setToolTip(
|
|
_("Time interval for autosaving. In milliseconds.\n"
|
|
"The application will try to save periodically but only\n"
|
|
"if the project was saved manually at least once.\n"
|
|
"While active, some operations may block this feature.")
|
|
)
|
|
|
|
grid0.addWidget(self.autosave_label, 32, 0)
|
|
grid0.addWidget(self.autosave_entry, 32, 1)
|
|
|
|
# self.as_ois = OptionalInputSection(self.autosave_cb, [self.autosave_label, self.autosave_entry], True)
|
|
|
|
separator_line = QtWidgets.QFrame()
|
|
separator_line.setFrameShape(QtWidgets.QFrame.HLine)
|
|
separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
|
|
grid0.addWidget(separator_line, 33, 0, 1, 2)
|
|
|
|
self.pdf_param_label = QtWidgets.QLabel('<B>%s:</b>' % _("Text to PDF parameters"))
|
|
self.pdf_param_label.setToolTip(
|
|
_("Used when saving text in Code Editor or in FlatCAM Document objects.")
|
|
)
|
|
grid0.addWidget(self.pdf_param_label, 34, 0, 1, 2)
|
|
|
|
# Top Margin value
|
|
self.tmargin_entry = FCDoubleSpinner()
|
|
self.tmargin_entry.set_precision(self.decimals)
|
|
self.tmargin_entry.set_range(0.0000, 10000.0000)
|
|
|
|
self.tmargin_label = QtWidgets.QLabel('%s:' % _("Top Margin"))
|
|
self.tmargin_label.setToolTip(
|
|
_("Distance between text body and the top of the PDF file.")
|
|
)
|
|
|
|
grid0.addWidget(self.tmargin_label, 35, 0)
|
|
grid0.addWidget(self.tmargin_entry, 35, 1)
|
|
|
|
# Bottom Margin value
|
|
self.bmargin_entry = FCDoubleSpinner()
|
|
self.bmargin_entry.set_precision(self.decimals)
|
|
self.bmargin_entry.set_range(0.0000, 10000.0000)
|
|
|
|
self.bmargin_label = QtWidgets.QLabel('%s:' % _("Bottom Margin"))
|
|
self.bmargin_label.setToolTip(
|
|
_("Distance between text body and the bottom of the PDF file.")
|
|
)
|
|
|
|
grid0.addWidget(self.bmargin_label, 36, 0)
|
|
grid0.addWidget(self.bmargin_entry, 36, 1)
|
|
|
|
# Left Margin value
|
|
self.lmargin_entry = FCDoubleSpinner()
|
|
self.lmargin_entry.set_precision(self.decimals)
|
|
self.lmargin_entry.set_range(0.0000, 10000.0000)
|
|
|
|
self.lmargin_label = QtWidgets.QLabel('%s:' % _("Left Margin"))
|
|
self.lmargin_label.setToolTip(
|
|
_("Distance between text body and the left of the PDF file.")
|
|
)
|
|
|
|
grid0.addWidget(self.lmargin_label, 37, 0)
|
|
grid0.addWidget(self.lmargin_entry, 37, 1)
|
|
|
|
# Right Margin value
|
|
self.rmargin_entry = FCDoubleSpinner()
|
|
self.rmargin_entry.set_precision(self.decimals)
|
|
self.rmargin_entry.set_range(0.0000, 10000.0000)
|
|
|
|
self.rmargin_label = QtWidgets.QLabel('%s:' % _("Right Margin"))
|
|
self.rmargin_label.setToolTip(
|
|
_("Distance between text body and the right of the PDF file.")
|
|
)
|
|
|
|
grid0.addWidget(self.rmargin_label, 38, 0)
|
|
grid0.addWidget(self.rmargin_entry, 38, 1)
|
|
|
|
self.layout.addStretch()
|
|
|
|
if sys.platform != 'win32':
|
|
self.portability_cb.hide()
|
|
|
|
# splash screen button signal
|
|
self.splash_cb.stateChanged.connect(self.on_splash_changed)
|
|
|
|
# Monitor the checkbox from the Application Defaults Tab and show the TCL shell or not depending on it's value
|
|
self.shell_startup_cb.clicked.connect(self.on_toggle_shell_from_settings)
|
|
|
|
self.language_apply_btn.clicked.connect(lambda: fcTranslate.on_language_apply_click(app=self.app, restart=True))
|
|
|
|
def on_toggle_shell_from_settings(self, state):
|
|
"""
|
|
Toggle shell ui: if is visible close it, if it is closed then open it
|
|
|
|
:return: None
|
|
"""
|
|
|
|
if state is True:
|
|
if not self.app.ui.shell_dock.isVisible():
|
|
self.app.ui.shell_dock.show()
|
|
else:
|
|
if self.app.ui.shell_dock.isVisible():
|
|
self.app.ui.shell_dock.hide()
|
|
|
|
@staticmethod
|
|
def on_splash_changed(state):
|
|
qsettings = QSettings("Open Source", "FlatCAM")
|
|
qsettings.setValue('splash_screen', 1) if state else qsettings.setValue('splash_screen', 0)
|
|
|
|
# This will write the setting to the platform specific storage.
|
|
del qsettings
|