def testConversions(self):
file_path = adjust_filename('qsettings_test.ini', __file__)
settings = QSettings(file_path, QSettings.IniFormat)
r = settings.value('var1')
self.assertEqual(type(r), list)
r = settings.value('var2')
if py3k.IS_PY3K:
self.assertEqual(type(r), str)
else:
self.assertEqual(type(r), unicode)
r = settings.value('var2', type=list)
self.assertEqual(type(r), list)
def __init__(self):
super(NotepadSettings, self).__init__()
self.setupUi(self)
self.btnCancel.clicked.connect(self.reject)
self.btnSave.clicked.connect(self.saveSettings)
settings = QSettings()
font = settings.value('Notepad/Font', 'Roboto')
fontSize = settings.value('Notepad/FontSize', 12.0)
tabSpace = settings.value('Notepad/TabSpace', 40)
self.comboFont.setCurrentFont(font)
self.spinFontSize.setValue(fontSize)
self.spinTab.setValue(tabSpace / 10)
def __init__(self, parent=None):
super(UserPreferencesDialog, self).__init__(parent)
self.userPreferencesDialog = getUiFromFile(
os.path.join(UI_DIR, "userpreferencesdialog.ui"))
self.fileDialog = QFileDialog()
self.userPreferencesSettingsFile = QSettings("Motivo GUI", "project20")
self.getMotivoDirectory()
self.userPreferencesDialog.setDirectoryButton.clicked.connect(
self.setMotivoDirectory)
self.userPreferencesDialog.selectMotivoDirectoryButton.clicked.connect(
self.openDirectoryBrowser)
def __init__(self, appctx):
super().__init__()
self.appctx = appctx
self.obs = None
self.tick_timer = QTimer()
self.tick_timer.setInterval(200)
self.tick_timer.timeout.connect(self.tick)
self.tick_timer.start()
company = 'dunkelstern' if sys.platform != 'darwin' else 'de.dunkelstern'
self.settings = QSettings(company, 'OBSTouchOSC')
self.init_ui()
self.load_settings()
def closeEvent(self, event):
self.rss.finish()
self.twidget.finish()
self.t2widget.finish()
settings = QSettings('dreamix Studio', 'rt-stats')
settings.setValue('main/size', self.size())
settings.setValue('main/pos', self.pos())
settings.setValue('main/rss/splitter', self.rss.splitter.saveState())
settings.setValue('main/new/splitter',
self.twidget.splitter.saveState())
settings.setValue('main/new/tree',
self.twidget.list.header().saveState())
settings.setValue('main/update/splitter',
self.t2widget.splitter.saveState())
event.accept()
def autopauseClick(self):
if not self.enableAutopause:
self.autopauseAct.setVisible(True)
self.disabledautopauseAct.setVisible(False)
self.obserwableValue.autopauseFlag = True
else:
self.autopauseAct.setVisible(False)
self.disabledautopauseAct.setVisible(True)
self.obserwableValue.autopauseFlag = False
self.enableAutopause = not self.enableAutopause
settings = QSettings()
settings.beginGroup("ScanToolbar")
settings.setValue("autopause", self.enableAutopause)
settings.endGroup()
def window_position(window):
screen = QDesktopWidget(window).availableGeometry()
default_size = screen.width() * 0.75, screen.height() * 0.75
default_pos = (screen.width() - default_size[0]) / 2, \
(screen.height() - default_size[1]) / 2
config = QSettings("justacid", "Segmate")
config.beginGroup("MainWindow")
size = config.value("size", QSize(*default_size))
pos = config.value("position", QPoint(*default_pos))
is_maximized = config.value("maximized", "false")
is_maximized = True if "true" in is_maximized else False
config.endGroup()
return size, pos, is_maximized
def _show_add_up_spine_opt_wizard(self):
use_emb_julia, julia_path, julia_project_path, julia_kernel = self._get_julia_settings(
)
settings = QSettings("SpineProject", "AddUpSpineOptWizard")
settings.setValue("appSettings/useEmbeddedJulia", use_emb_julia)
settings.setValue("appSettings/juliaPath", julia_path)
settings.setValue("appSettings/juliaProjectPath", julia_project_path)
settings.setValue("appSettings/juliaKernel", julia_kernel)
julia_env = get_julia_env(settings)
if julia_env is None:
julia_exe = julia_project = ""
else:
julia_exe, julia_project = julia_env
wizard = AddUpSpineOptWizard(self, julia_exe, julia_project)
wizard.show()
def load_settings(self):
settings = QSettings()
self.config['instrument'] = settings.value('config_instrument', None)
self.config['calibration'] = settings.value('config_calibration', None)
self.images_dir = settings.value('images_dir', None)
self.hdf5_path = settings.value('hdf5_path', None)
# All QSettings come back as strings.
self.live_update = bool(settings.value('live_update', True) == 'true')
conv = settings.value('euler_angle_convention', ('xyz', True))
self.set_euler_angle_convention(conv[0], conv[1], convert_config=False)
self.previous_active_material = settings.value('active_material', None)
self.collapsed_state = settings.value('collapsed_state', [])
self.load_panel_state = settings.value('load_panel_state', None)
def on_load_file(self):
"""Allow to automatically add words from a file
See Also:
:meth:`load_file`
"""
# Reload last directory used
last_directory = QSettings().value("last_directory", QDir.homePath())
filepath, _ = QFileDialog.getOpenFileName(self,
self.tr("Open Word set"),
last_directory,
self.tr("Text file (*.txt)"))
if filepath:
self.load_file(filepath)
def restoreState(self):
"""
restores the state of the main window including the dock windows of Services
:return:
"""
logger.info("restoring main window's state")
settings = QSettings()
v = settings.value("MainWindowState")
if v is not None:
super().restoreState(v)
v = settings.value("MainWindowGeometry")
if v is not None:
self.restoreGeometry(v)
if self.toolbar is not None:
self.toolbar.show()
def _start_session(self):
if self._session is not None:
return
self._session = QProcess(self)
self._session.finished.connect(self._session_ended)
self._session.readyReadStandardOutput.connect(self._log_append_stdout)
self._session.readyReadStandardError.connect(self._log_append_stderr)
settings = QSettings()
self._session.start(sys.executable, [
'run_session.py',
settings.value('CyKitAddress', app.DEFAULT_CYKIT_ADDRESS),
str(settings.value('CyKitPort', app.DEFAULT_CYKIT_PORT)),
str(self._interaction_server.port)
])
def __init__(self, parent):
super(TextModuleWidget, self).__init__()
self.parent = parent
self.settings = QSettings(c.SETTINGS_PATH, QSettings.IniFormat)
self.table = QTableWidget()
self.init_table()
self.save_btn = QPushButton("Save")
self.save_btn.clicked.connect(self.on_save)
self.v_box = QVBoxLayout()
self.v_box.addWidget(self.table)
self.v_box.addWidget(self.save_btn)
self.setLayout(self.v_box)
def __init__(self):
super().__init__()
self.title = 'LawNet Reading List Downloader (LRLD)'
self.left = 600
self.top = 400
self.width = 800
self.height = 500
self.download_directory = None
self.reading_list_directory = None
self.citation_list = []
self.stared_only = False
self.settings = QSettings('LegalList')
self.load_settings()
self.initUI()
self.downloader = lawnetsearch.LawnetBrowser()
self.successful_downloads = 0
def store_window_geometry(self):
"""
Stores the current window geometry for the QWindow
The .geometry() method on QWindow includes the size of the application minus the window frame.
For that reason the _blender_widget should be used.
"""
settings = QSettings('Tech-Artists.org', 'Blender Qt Wrapper')
settings.beginGroup(self._settings_key_window_group_name)
settings.setValue(self._settings_key_geometry,
self.blender_widget.geometry())
settings.setValue(self._settings_key_maximized,
self.blender_widget.isMaximized())
settings.setValue(self._settings_key_full_screen,
self.blender_widget.isFullScreen())
settings.endGroup()
def __init__(self):
super(MainWindow, self).__init__()
self.settings = QSettings("j33433", "MPowerTCX")
WidgetSettings.__init__(self, self, 'settings.json', self.settings)
self.version = version.version
self.trues = [True, 'True', 'true'] # workaround for pyside
self.setupUi(self)
# self.menuHelp.menuAction().setMenuRole(QAction.AboutRole)
# self.menuBar().setMenuRole(QAction.AboutRole)
self.unstash()
self.assignWidgets()
self.configure()
self.show()
self.mpower = None
self.in_file_info = None
self.resize(self.width(), self.minimumSizeHint().height())
def accept(self):
super().accept()
settings = QSettings()
cykit_address = self.cykit_address_field.text()
if cykit_address:
settings.setValue('CyKitAddress', cykit_address)
else:
settings.remove('CyKitAddress')
cykit_port = self.cykit_port_field.text()
if cykit_port:
settings.setValue('CyKitPort', cykit_port)
else:
settings.remove('CyKitPort')
def save(self):
settings = QSettings()
settings.beginGroup(self.__class__.__name__)
settings.beginWriteArray('col_size')
for i in range(3):
settings.setArrayIndex(i)
w = self.columnWidth(i)
if i != 0 or w != 0:
settings.setValue('col', w)
settings.endArray()
if self.ini_check:
settings.setValue('display_images',
self.images_display.checkState() == Qt.Checked)
settings.setValue('use_cache', self.use_cache)
settings.setValue('cache_size', self.cache_size)
settings.endGroup()
def get_data_path(name_project):
settings = QSettings("Nebula", name_project)
settings.beginGroup("SignalFiles")
signal_value_path = settings.value("ValuePath")
settings.endGroup()
try:
print(signal_value_path)
signal_value_path = signal_value_path.split(',')
if 'None' in signal_value_path:
signal_value_path.remove('None')
print(f'DESDE GET_DATA: {signal_value_path}')
except:
print('First load a project')
signal_value_path = ['None']
finally:
return signal_value_path
def getAutopauseFlagFormSettings(self):
if self.parent.tedaCommandLine.ignoreSettings:
return True
settings = QSettings()
settings.beginGroup("ScanToolbar")
flag = settings.value("autopause")
settings.endGroup()
if flag != None:
if flag=="true":
return True
else:
return False
else:
return True
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 __init__(self, *args, **kwargs):
super(Application, self).__init__(*args, **kwargs)
# setup the application name and icon
self.setApplicationName('Qui')
self.iconPath = os.path.dirname(__file__)
self.iconPath = os.path.join(self.iconPath, 'icons/icon.png')
self.setWindowIcon(QIcon(self.iconPath))
# setup the tray icon
self.showNotifications = False
self.tray = QSystemTrayIcon(QIcon(self.iconPath))
self.tray.show()
self.tray.activated.connect(self.showWindow)
# setup the tray icon menu
self.menu = QMenu()
self.menu.addAction('Quit').triggered.connect(self.quit)
self.tray.setContextMenu(self.menu)
# setup signals
self.messageReceived.connect(self.receiveMessage)
# show the window
self.window = None
self.showWindow(None)
# try loading the login info
self.client = None
self.settings = QSettings('Qui', 'Qui')
self.url = self.settings.value("url")
self.token = self.settings.value("token")
self.user = self.settings.value("user")
invalid = self.url is None or self.url == "" or self.token is None or self.token == "" or self.user is None or self.user == ""
if not invalid:
try:
self.client = MatrixClient(base_url=self.url,
token=self.token,
user_id=self.user)
self.postLogin()
except:
invalid = True
# show the login form if we can't login
if invalid:
self.loginForm = LoginForm()
self.loginForm.loggedIn.connect(self.login)
self.loginForm.show()
def __init__(self, model, parent=None):
super().__init__(parent)
self.model = model
self.chosen_user_record = None
self.settings = QSettings()
default_user = self.settings.value("default_user", 0)
self.setWindowTitle(self.tr("pyOffer - Choose user"))
icon = QIcon()
icon.addFile(u":/ico")
self.setWindowIcon(icon)
top_level_layout = QtWidgets.QVBoxLayout(self)
logo_label = QtWidgets.QLabel(self)
logo = QPixmap()
logo.load(u":/klog")
logo_label.setPixmap(logo)
logo_label.setAlignment(Qt.AlignCenter)
top_level_layout.addWidget(logo_label)
horizontal_layout = QtWidgets.QHBoxLayout()
icon_label = QtWidgets.QLabel(self)
pixmap = QPixmap(":/user").scaled(128, 128, Qt.KeepAspectRatio)
icon_label.setPixmap(pixmap)
icon_label.setAlignment(Qt.AlignCenter)
horizontal_layout.addWidget(icon_label)
vertical_layout = QtWidgets.QVBoxLayout()
label_description = QtWidgets.QLabel(self)
label_description.setText(self.tr("Please choose user:"))
vertical_layout.addWidget(label_description)
self.list_view = QtWidgets.QListView(self)
self.list_view.setModel(self.model)
self.list_view.setModelColumn(1)
self.list_view.setSelectionBehavior(QtWidgets.QListView.SelectRows)
self.list_view.setCurrentIndex(self.model.index(default_user, 1))
vertical_layout.addWidget(self.list_view)
self.buttons = QtWidgets.QDialogButtonBox(
QtWidgets.QDialogButtonBox.Ok | QtWidgets.QDialogButtonBox.Cancel)
self.buttons.accepted.connect(self.ok)
self.buttons.rejected.connect(self.reject)
vertical_layout.addWidget(self.buttons)
horizontal_layout.addLayout(vertical_layout)
top_level_layout.addLayout(horizontal_layout)
def __init__(self, main_window, instance):
self._main_window = main_window
self._instance = instance
self.is_split = False
self.split_tab_id = 0
instance.workspace = self
self.view_manager: ViewManager = ViewManager(self)
self.plugins: PluginManager = PluginManager(self)
self.current_screen = ObjectContainer(None, name="current_screen")
#
# Initialize font configurations
#
self.default_tabs = [
FunctionsView(self, 'left'),
DisassemblyView(self, 'center'),
CodeView(self, 'center'),
]
if Conf.has_operation_mango:
self.default_tabs.append(
DependencyView(self, 'center')
)
self.default_tabs += [
SymexecView(self, 'center'),
StatesView(self, 'center'),
StringsView(self, 'center'),
PatchesView(self, 'center'),
InteractionView(self, 'center'),
ConsoleView(self, 'bottom'),
]
if has_binsync():
self.default_tabs.append(SyncView(self, 'right'))
#
# Save initial splitter state
#
self.splitter_state = QSettings()
self.splitter_state.setValue("splitterSizes", self._main_window.central_widget_main.saveState())
for tab in self.default_tabs:
self.add_view(tab, tab.caption, tab.category)
def __init__(self):
QMainWindow.__init__(self)
self.settings = QSettings('karoStudio', 'rt-stats')
self.resize(self.settings.value('main/size', QSize(640, 480)))
self.move(self.settings.value('main/pos', QPoint(200, 200)))
self.ds = DataSource()
cats = self.ds.get_categories()
self.layout = QGridLayout()
list_cats = QWidget()
list_cats.setLayout(self.layout)
self.content = QScrollArea()
for row, cat in enumerate(cats):
lbl = QPushButton(cat['title'])
lbl.setFont(QFont(pointSize=70))
self.layout.addWidget(lbl, row, 0, Qt.AlignTop)
self.content.setViewport(list_cats)
self.setCentralWidget(self.content)
def process_settings(self, project_name, action_name):
self.project_name = project_name
self.action_name.append(action_name)
self.settings = QSettings("Nebula", self.project_name)
self.settings.beginGroup("ProcessInfo")
self.settings.beginWriteArray(action_name)
s = [str(i) for i in self.dat[project_name]]
res = ",".join(s)
for i in range(len(self.process_name)):
self.settings.setArrayIndex(i)
self.settings.setValue("Name", self.process_name[i])
self.settings.setValue("Description", self.process_description[i])
self.settings.setValue("Value", res)
self.settings.endArray()
self.settings.endGroup()
print(self.settings.fileName())
return self.settings.fileName()
def init_ui(self):
self.settings = QSettings(__data__.__author__, __data__.__name__)
font_size = self.settings.value('line_edit_font_size', 0)
main_layout = QGridLayout()
main_layout.addWidget(QLabel("before:"), 0, 0)
main_layout.addWidget(QLabel("after:"), 2, 0)
main_layout.addWidget(QLabel("change:"), 4, 0)
self.before_edit = self.make_edit(placeholder='before', font_size=font_size)
self.after_edit = self.make_edit(placeholder='after', font_size=font_size)
self.change_edit = self.make_change_edit(placeholder='change', font_size=font_size)
self.calc_before_radio = self.make_calc_radio_button(shortcut='ALT+b', calc_function=calc_before,
calc_target=self.before_edit)
self.calc_after_radio = self.make_calc_radio_button(shortcut='ALT+a', calc_function=calc_after,
calc_target=self.after_edit)
self.calc_change_radio = self.make_calc_radio_button(shortcut='ALT+c', calc_function=calc_change,
calc_target=self.change_edit)
main_layout.addWidget(self.before_edit, 1, 0)
main_layout.addWidget(self.calc_before_radio, 1, 1)
main_layout.addWidget(self.after_edit, 3, 0)
main_layout.addWidget(self.calc_after_radio, 3, 1)
main_layout.addWidget(self.change_edit, 5, 0)
main_layout.addWidget(self.calc_change_radio, 5, 1)
self.setLayout(main_layout)
about_btn = QPushButton('ab&out...')
about_btn.setFocusPolicy(Qt.ClickFocus)
@about_btn.clicked.connect
def show_help(event):
message = '\n'.join([
__data__.__name__ + ' v' + __data__.__version__,
f'by ' + __data__.__author__
])
QMessageBox.information(self, 'about increment', message)
main_layout.addWidget(about_btn, 0, 1)
self.calc_change_radio.setChecked(True)
def __init__(self, parent):
super().__init__(parent)
self._setting = QSettings() # ORGANIZATION_NAME, APPLICATION_NAME)
self._tabWidget = QTabWidget()
self._tabGeneral = QWidget()
self._tabIndex = QWidget()
self._tabIndexSche=QWidget()
self._ckb_show_window_on_start = QCheckBox()
self._ckb_show_indicator = QCheckBox()
self._buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self._init_ui()
self._init_conn()
self._read_settings()
def __init__(self):
QMainWindow.__init__(self, parent=None)
self.settings = QSettings(ORGANIZATION_STR)
self.toolbar = self.createToolBar()
self.widget = QWidget(self)
self.layout = QVBoxLayout(self.widget)
self.layout.setContentsMargins(1, 1, 1, 1)
self.currentWidget = None
self.editor = QTextEdit()
self.editor.setAcceptRichText(False)
font = QFontDatabase.systemFont(QFontDatabase.FixedFont)
fs = int(self.settings.value("fontSize", 13))
font.setPointSize(fs)
self.editor.setFont(font)
self.preview = MarkdownRenderer()
self.layout.addWidget(self.toolbar)
self.widget.setLayout(self.layout)
self.showWidget(self.editor)
self.addToolBar(self.toolbar)
self.setCentralWidget(self.widget)
self.setWindowTitle(BASIC_TITLE)
self.nbManager = NotebookManager()
self.currentNotebook = None
self.currentNote = None
self.dirty = False
self.editor.document().modificationChanged.connect(self.editorModified)
self.updateUI()
if len(self.nbManager.notebooks()) > 0:
self.switchNotebook(self.nbManager.notebooks()[0].name)
self.createTrayIcon()
self.readConfig()
def __init__(self, parent=None):
super(TypingWindow, self).__init__(parent=parent)
# TODO: Implement themes system
self.config = {
'error_color': QColor(255, 190, 190),
'done_color': QColor(190, 255, 190),
'secondary_color': QColor(230, 230, 230),
'background_color': QColor(255, 255, 255),
'primary_color': QColor(34, 34, 34),
'dictionary': english_words_set
}
self.setupWindow()
self.settings = QSettings(QCoreApplication.applicationName(),
parent=self)
self.reset()
