def __loadGeometry(self):
settings = QSettings("Intel_OTC", "obslightgui")
propMap = {
"mainWindow/geometry": self.__mainWindow.restoreGeometry,
"mainWindow/state": self.__mainWindow.restoreState,
"mainWindow/splitter2State":
self.__mainWindow.splitter_2.restoreState,
"mainWindow/splitter3State":
self.__mainWindow.splitter_3.restoreState,
"mainWindow/splitter4State":
self.__mainWindow.splitter_4.restoreState,
"mainWindow/splitter5State":
self.__mainWindow.splitter_5.restoreState,
"mainWindow/splitter6State":
self.__mainWindow.splitter_6.restoreState,
"mainWindow/splitterState":
self.__mainWindow.splitter.restoreState,
"mainWindow/splitterGeo":
self.__mainWindow.splitter.restoreGeometry,
"logWindow/geometry": self.__logManager.restoreGeometry
}
for propName, func in propMap.iteritems():
prop = settings.value(propName)
if prop is not None:
func(prop)
def editingFinishedHandler(self):
settings = QSettings()
old = settings.value("computation/reduce",QtReduceDefaults.REDUCE)
new = self.reduceBinary.text()
if old == new:
return
self.reduceBinary.blockSignals(True)
tit = "Change Binary?"
txt = self.tr("Do you really want to change this setting?")
itxt = self.tr("If yes, then the binary ")
itxt += '"' + new + '" '
itxt += self.tr("will be used at the next restart.")
mbox = QMessageBox(self)
mbox.setIcon(QMessageBox.Question)
mbox.setWindowModality(Qt.WindowModal)
mbox.setWindowTitle(tit)
mbox.setText(txt)
mbox.setInformativeText(itxt)
mbox.setStandardButtons(QMessageBox.Yes|QMessageBox.No)
button = mbox.exec_()
if button == QMessageBox.Yes:
settings.setValue("computation/reduce",new)
else:
self.reduceBinary.setText(old)
self.reduceBinary.blockSignals(False)
def confirmSubs(self, playersIn, playersOut, datetime):
week = gameinfo.weekNum(datetime) + 1
date = gameinfo.weekToDate(week).date()
html = render_to_string(
'subs_email.html', {
'team': self.team,
'players_in': playersIn,
'players_out': playersOut,
'week': week,
'date': date
})
settings = QSettings()
if settings.contains('SMTP/Server'):
smtp_server = settings.value('SMTP/Server')
else:
smtp_server = None
if not smtp_server:
QMessageBox.critical(self, "Email Error",
"Please add an SMTP server in settings.")
else:
email = HTMLEmail([self.team.email],
"*****@*****.**",
"Fantasy Football League",
bcc='*****@*****.**')
email.sendMail("Sub Confirmation", html, smtp_server)
def Execute(self, filename=None):
if filename is None:
settings = QSettings("NoCompany", "KowArmyBuilder")
preferredFolder = settings.value("preferred_folder")
if preferredFolder is None: preferredFolder = ".."
filename, _ = QtGui.QFileDialog.getOpenFileName(self._mdiArea, "Open army list", preferredFolder, "Army lists (*.lst);;All files (*.*)")
if len(filename)==0: return
else: settings.setValue("preferred_folder", os.path.dirname(filename))
# check if the file is already open
for wnd in self._mdiArea.subWindowList():
if hasattr(wnd.widget(), '_lastFilename') and wnd.widget()._lastFilename == filename: # be sure not to check preview or other windows --- this is ugly. TODO: Better solution
self._mdiArea.setActiveSubWindow(wnd)
return
alr = ArmyListReader(QtGui.qApp.DataManager)
try: armylist, warnings = alr.LoadFromFile(filename)
except IOError as e:
QtGui.QMessageBox.critical(self._mdiArea, "Error loading %s" % filename, "We're sorry, the file could not be loaded.\nError message:\n %s" % (e))
return False
except Exception as e:
QtGui.QMessageBox.critical(self._mdiArea, "Error loading %s" % filename, "We're sorry, the file could not be loaded.\nAn unknown error occurred. Error message:\n %s" % (e))
return False
if warnings != []:
QtGui.QMessageBox.warning(self._mdiArea, "Warning", "File %s was successfully loaded, but there were warnings:\n" % os.path.basename(filename) + "\n".join(warnings))
view = self._mdiArea.AddArmySubWindow(ArmyListModel(armylist))
view.SetLastFilename(filename)
QtGui.qApp.DataManager.AddRecentFile(filename)
view.siRecentFilesChanged.emit()
print view.ctrl._views
return view
def save_ini(self):
settings = QSettings('config.ini', QSettings.IniFormat)
settings.beginGroup(self.__class__.__name__)
settings.setValue('Geometry', self.saveGeometry())
settings.setValue('splitter', self.splitter.saveState())
settings.endGroup()
def icon(self, act):
settings = QSettings()
iconSet = settings.value("toolbar/iconset", QtReduceDefaults.ICONSET)
iconSize = settings.value("toolbar/iconsize",
QtReduceDefaults.ICONSIZE)
if iconSet:
iEntry = self.db[iconSet]
text = act.iconText()
entry = None
if text in iEntry.keys():
entry = iEntry[text]
path = ''
if entry:
path = sys.path[0] + "/icons/" + iconSet + "/"
if iEntry["sized"]:
path += str(iconSize) + "/"
path += entry
traceLogger.debug("iconPath=%s" % path)
return QIcon(path)
else:
if mEntry == "open":
return self.style().standardIcon(QStyle.SP_DialogOpenButton)
elif mEntry == "save":
return self.style().standardIcon(QStyle.SP_DialogSaveButton)
elif mEntry == "abort":
return self.style().standardIcon(QStyle.SP_BrowserStop)
else:
return QIcon('')
def Execute(self):
defaultName = self.alView._lastFilename if self.alView._lastFilename else "%s.lst" % self.alModel.data.CustomName()
if (not self.alView._lastFilename) or self.saveAs:
settings = QSettings("NoCompany", "KowArmyBuilder")
preferredFolder = settings.value("preferred_folder")
if preferredFolder is None: preferredFolder = ".."
filename, _ = QtGui.QFileDialog.getSaveFileName(self.alView, "Save army list as", "%s" % (os.path.join(preferredFolder, defaultName)),
"Army lists (*.lst);;All files (*.*)")
if filename == "": return
else: self.alView._lastFilename = filename
QtGui.qApp.DataManager.AddRecentFile(filename)
settings.setValue("preferred_folder", os.path.dirname(filename))
self.alView.siRecentFilesChanged.emit()
else:
filename = self.alView._lastFilename
try:
alw = ArmyListWriter(self.alModel.data)
alw.SaveToFile(filename)
except IOError as e:
QtGui.QMessageBox.critical(self.alView, "Error while saving", "An error occurred while saving the army list:\n %s" % e)
else:
self.alModel.modified = False
self.hints = (ToggleModifiedHint(), )
def confirmSubs(self, playersIn, playersOut, datetime):
week = gameinfo.weekNum(datetime) + 1
date = gameinfo.weekToDate(week).date()
html = render_to_string('subs_email.html', {'team': self.team,
'players_in': playersIn,
'players_out': playersOut,
'week': week,
'date': date}
)
settings = QSettings()
if settings.contains('SMTP/Server'):
smtp_server = settings.value('SMTP/Server')
else:
smtp_server = None
if not smtp_server:
QMessageBox.critical(self, "Email Error", "Please add an SMTP server in settings.")
else:
email = HTMLEmail([self.team.email],
"*****@*****.**",
"Fantasy Football League",
bcc='*****@*****.**')
email.sendMail("Sub Confirmation", html, smtp_server)
def repository(self, value):
settings = QSettings("csaez", "mauto")
settings.setValue("repo", value)
if not os.path.exists(value):
os.makedirs(value)
self._repo = value
self.reload()
def accept(self):
settings = QSettings()
language = LanguageKind(
settings.value(Gopt.Key.Language, Gopt.Default.Language))
if self.configCheckBox.isChecked():
sortasrules = Gopt.Default.SortAsRules
pagerangerules = Gopt.Default.PageRangeRules
else:
sortasrules = self.state.model.sortAsRules()
pagerangerules = self.state.model.pageRangeRules()
copyInfo = CopyInfo(self.state.model.filename,
self.filenameLabel.text(),
self.configCheckBox.isChecked(),
self.customMarkupCheckBox.isChecked(),
self.spellWordsCheckBox.isChecked(),
self.ignoredFirstWordsCheckBox.isChecked(),
self.autoReplaceCheckBox.isChecked(),
self.groupsCheckBox.isChecked(),
self.state.model.username, language, sortasrules,
pagerangerules)
self.state.window.closeXix()
self.state.model.copyEmpty(copyInfo)
self.state.window.openXix(copyInfo.newname)
self.state.entryPanel.clearForm()
self.state.setMode(ModeKind.VIEW)
super().accept()
def setShowMainWindowToolTips(self):
showMainWindowToolTips = int(
self.showMainWindowToolTipsCheckBox.isChecked())
settings = QSettings()
settings.setValue(Gopt.Key.ShowMainWindowToolTips,
showMainWindowToolTips)
self.state.window.updateToolTips()
def initialize(self):
self.setWindowTitle("{}".format(QApplication.applicationName()))
self.state.updateDisplayFonts()
self.filename = None
if len(sys.argv) > 1:
filename = sys.argv[1]
if (filename.lower().endswith(EXTENSION)
and os.path.exists(filename)):
self.filename = filename
if self.filename is None:
settings = QSettings()
filename = settings.value(Gopt.Key.MainForm_Filename,
Gopt.Default.MainForm_Filename)
if (filename and filename.lower().endswith(EXTENSION)
and os.path.exists(filename)):
self.filename = filename
if self.filename is None:
say("Click File→New or File→Open to create or open an index")
self.updateWorkTime()
self.state.updateUi()
else:
say("Opening {}".format(os.path.normpath(self.filename)))
QTimer.singleShot(5, self.openXix)
self.updateRecentFilesMenu()
self.updateToolTips()
Lib.maybe_register_filetype(self.debug)
class PadApp(QApplication):
def __init__(self, *args, **kwargs):
QApplication.__init__(self, *args, **kwargs)
self.settings = QSettings('everpad', 'everpad-pad')
self.translator = QTranslator()
if not self.translator.load('../../i18n/%s' % QLocale.system().name()):
self.translator.load('/usr/share/everpad/i18n/%s' % QLocale.system().name())
# This application string can be localized to 'RTL' to switch the application layout
# direction. See for example i18n/ar_EG.ts
QT_TRANSLATE_NOOP('QApplication', 'QT_LAYOUT_DIRECTION')
self.installTranslator(self.translator)
QNetworkProxyFactory.setUseSystemConfiguration(True)
self.indicator = Indicator(self)
self.update_icon()
self.indicator.show()
def update_icon(self):
if int(self.settings.value('black-icon', 0)):
self.icon = QIcon.fromTheme('everpad-black', QIcon('../../data/everpad-black.png'))
else:
self.icon = QIcon.fromTheme('everpad-mono', QIcon('../../data/everpad-mono.png'))
self.indicator.setIcon(self.icon)
def send_notify(self, text):
self.indicator.showMessage('Everpad', text,
QSystemTrayIcon.Information)
def on_sync_state_changed(self, state):
if bool(self.settings.value('launcher-progress', 1)):
self.launcher.update({
'progress': float(state + 1) / len(SYNC_STATES),
'progress-visible': state not in (SYNC_STATE_START, SYNC_STATE_FINISH),
})
def printIndex(self):
widget = QApplication.focusWidget()
if self.state.printer is None:
self.state.printer = QPrinter(QPrinter.HighResolution)
self.state.printer.setColorMode(QPrinter.GrayScale)
settings = QSettings()
size = PaperSizeKind(
int(settings.value(Gopt.Key.PaperSize,
Gopt.Default.PaperSize)))
self.state.printer.setPaperSize(
QPrinter.Letter if size is PaperSizeKind.LETTER else QPrinter.
A4)
with Lib.Qt.DisableUI(*self.window.widgets(), forModalDialog=True):
form = QPrintDialog(self.state.printer, self.state.window)
form.setWindowTitle("Print Index")
if form.exec_():
try:
with Lib.DisableUI(*self.window.widgets()):
config = self.state.model.configs().copy()
config.Filename = "print.$$$"
config.Printer = self.state.printer
Output.outputEntries(self.state.model, config,
"Printing",
self.window.reportProgress)
say("Printed")
except Output.Error as err:
say("Failed to print: {}".format(err))
logging.error("printIndex failed: {}".format(err))
Lib.restoreFocus(widget)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.current_directory = None
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope,
COMPANY, APPNAME)
self.restoreGeometry(self.settings.value(self.__class__.__name__))
self.splitter.restoreState(self.settings.value(SPLITTER))
self.current_directory = self.settings.value(CURRENT_DIRECTORY)
self.white_albatross = WhiteAlbatrossWidget()
self.white_albatross.figuresChanged.connect(self.on_figures_changed)
self.workLayout.insertWidget(1, self.white_albatross)
self.type.currentIndexChanged.connect(self.white_albatross.setType)
self.type.setCurrentIndex(
int(self.settings.value(LAST_FIGURE_TYPE, defaultValue=0)))
self.addImages.clicked.connect(self.add_images_click)
self.openFolder.clicked.connect(self.open_folder_clicked)
self.removeImages.clicked.connect(self.remove_images)
self.imagesList.itemSelectionChanged.connect(self.item_selected)
self.deleteFigure.clicked.connect(self.delete_figure)
self.figures.customContextMenuRequested.connect(
self.figures_context_menu)
if self.current_directory:
self.open_folder()
self.imagesList.setCurrentRow(
int(self.settings.value(SELECTED_IMAGE, defaultValue=0)))
def icon(self, act):
settings = QSettings()
iconSet = settings.value("toolbar/iconset",QtReduceDefaults.ICONSET)
iconSize = settings.value("toolbar/iconsize",
QtReduceDefaults.ICONSIZE)
if iconSet:
iEntry = self.db[iconSet]
text = act.iconText()
entry = None
if text in iEntry.keys():
entry = iEntry[text]
path = ''
if entry:
path = sys.path[0] + "/icons/" + iconSet + "/"
if iEntry["sized"]:
path += str(iconSize) + "/"
path += entry
traceLogger.debug("iconPath=%s" % path)
return QIcon(path)
else:
if mEntry == "open":
return self.style().standardIcon(QStyle.SP_DialogOpenButton)
elif mEntry == "save":
return self.style().standardIcon(QStyle.SP_DialogSaveButton)
elif mEntry == "abort":
return self.style().standardIcon(QStyle.SP_BrowserStop)
else:
return QIcon('')
def findSizes(self,font):
fontLogger.debug("font.key()=%s" % font.key())
fontDatabase = QFontDatabase()
self.sizeCombo.blockSignals(True)
self.sizeCombo.clear()
self.sizeComboFs.blockSignals(True)
self.sizeComboFs.clear()
styleStr = fontDatabase.styleString(font)
if fontDatabase.isSmoothlyScalable(font.family(),styleStr):
for size in QFontDatabase.standardSizes():
self.sizeCombo.addItem(str(size))
self.sizeComboFs.addItem(str(size))
else:
for size in fontDatabase.smoothSizes(font.family(),styleStr):
self.sizeCombo.addItem(str(size))
self.sizeComboFs.addItem(str(size))
self.sizeCombo.blockSignals(False)
self.sizeComboFs.blockSignals(False)
currentSize = unicode(QSettings().value("worksheet/fontsize",
QtReduceDefaults.FONTSIZE))
sizeIndex = self.sizeCombo.findText(currentSize)
self.sizeCombo.setCurrentIndex(sizeIndex)
currentSize = unicode(QSettings().value("worksheet/fontsizefs",
QtReduceDefaults.FONTSIZEFS))
sizeIndex = self.sizeCombo.findText(currentSize)
self.sizeComboFs.setCurrentIndex(sizeIndex)
def setUp(self):
self.settings = QSettings('com.nokia.qt.serviceframework.tests',
'SampleServicePlugin')
self.manager = QServiceManager()
self.serviceXml = os.path.join(os.path.dirname(__file__),
'sampleservice.xml')
class PadApp(QApplication):
def __init__(self, *args, **kwargs):
QApplication.__init__(self, *args, **kwargs)
self.settings = QSettings("everpad", "everpad-pad")
self.translator = QTranslator()
if not self.translator.load("../../i18n/%s" % QLocale.system().name()):
self.translator.load("/usr/share/everpad/i18n/%s" % QLocale.system().name())
# This application string can be localized to 'RTL' to switch the application layout
# direction. See for example i18n/ar_EG.ts
QT_TRANSLATE_NOOP("QApplication", "QT_LAYOUT_DIRECTION")
self.installTranslator(self.translator)
self.indicator = Indicator(self)
self.update_icon()
self.indicator.show()
def update_icon(self):
if int(self.settings.value("black-icon", 0)):
self.icon = QIcon.fromTheme("everpad-black", QIcon("../../data/everpad-black.png"))
else:
self.icon = QIcon.fromTheme("everpad-mono", QIcon("../../data/everpad-mono.png"))
self.indicator.setIcon(self.icon)
def send_notify(self, text):
self.indicator.showMessage("Everpad", text, QSystemTrayIcon.Information)
def on_sync_state_changed(self, state):
if int(self.settings.value("launcher-progress", 1)):
self.launcher.update(
{
"progress": float(state + 1) / len(SYNC_STATES),
"progress-visible": state not in (SYNC_STATE_START, SYNC_STATE_FINISH),
}
)
class Window(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setWindowTitle('Liquid Emerald')
self.setWindowIcon(QIcon(QPixmap('emerald.png')))
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, 'VenusGames', 'LiquidEmerald')
self.restoreGeometry(self.settings.value(self.__class__.__name__))
connection1 = Connection()
self.block = Block(columns=[
Column(width=30),
Column(blocks=[
Block(left_pins=[
Pin(left_connections=[
connection1.end
]),
Pin()
]),
Block(columns=[
Column(blocks=[
Block(columns=[
Column(width=30),
Column(blocks=[
Block(size=QSize(40, 20)),
Block()
])
], left_pins=[
Pin(),
Pin()
], right_pins=[
Pin()
]),
Block()
]),
Column()
], right_pins=[
Pin()
])
]),
Column(blocks=[
Block(size=QSize(30, 30))
])
], left_pins=[
Pin(right_connections=[
connection1.start
])
])
def paintEvent(self, event):
self.block.paint(QPainter(self), QPoint(5, 5))
def closeEvent(self, event):
self.settings.setValue(self.__class__.__name__, self.saveGeometry())
def keyPressEvent(self, event):
if event.key() == Qt.Key_Escape:
self.close()
def setUp(self):
self.working_dir = tempfile.mkdtemp()
# Because uh, QSettings has very nice API so we need this
QSettings.setDefaultFormat(QSettings.Format.IniFormat)
# and this line, which include
QSettings.setPath(
QSettings.Format.IniFormat, # this arg
QSettings.Scope.SystemScope,
self.working_dir,
)
# to have our test settings isolated from the real application.
# Insert profanity here: ________________
# now we make our info
info = PMR()
self.endpoints = [
(info.host() + '/pmr2-dashboard',
TestAdapter(stream=workspace_home)),
('http://example.com/dashboard/addworkspace',
TestAdapter(stream='',
headers={
'Location': 'http://example.com/w/+/addworkspace',
})),
(
'http://example.com/w/+/addworkspace',
TestAdapter(
# XXX need to make this a real thing when we test that
# responses from server matters.
stream='',
headers={
'Location': 'http://example.com/w/1',
})),
(
'http://example.com/hgrepo',
TestAdapter(
# XXX need to make this a real thing when we test that
# responses from server matters.
stream='{"url": "http://example.com/hgrepo", '
'"storage": "git"}', )),
(
'http://example.com/w/1',
TestAdapter(
# XXX need to make this a real thing when we test that
# responses from server matters.
stream='{"url": "http://example.com/w/1", '
'"storage": "git"}', )),
('http://example.com/w/1/request_temporary_password',
TestAdapter(stream='{"user": "******", "key": "secret"}', )),
(info.host() + '/search',
TestAdapter(stream='[{"title": "Test Workspace", '
'"target": "http://example.com/w/1"}]', )),
]
# and tool, with the end points.
self._tool = self.make_tool()
def __init__(self):
assert self._instance == None
Config._instance = self
QCoreApplication.setOrganizationName("nicolas.carrier")
QCoreApplication.setApplicationVersion(version)
QCoreApplication.setApplicationName("gem")
self.__settings = QSettings()
def QsaveParameter(paramName, paramValue, quiet=False):
from PySide.QtCore import QSettings
if quiet == False:
print('saving Qparameter: %s' % paramName)
print(' parameter value: ', paramValue)
settings = QSettings("TCfA", "CPEDS")
settings.setValue(paramName, paramValue)
def zoomDef(self, fullScreen):
if fullScreen:
fs = int(QSettings().value("worksheet/fontsizefs",
QtReduceDefaults.FONTSIZEFS))
else:
fs = int(QSettings().value("worksheet/fontsize",
QtReduceDefaults.FONTSIZE))
self.setupFont(fs)
def writeSettings(self):
settings = QSettings()
settings.setValue("main/geometry", self.saveGeometry())
settings.setValue("main/windowState", self.saveState())
settings.setValue("main/currentFile", self.runningFile)
self.environmentDock.writeSettings()
self.debugDock.writeSettings()
def __init__(self, app):
super(MainWindow, self).__init__()
# Window layout - a splitter with the image on the left and controls
# on the right
self._image_widget = ImageLabel(self)
self._controls = Controls(self)
self._splitter = QSplitter()
self._splitter.addWidget(self._image_widget)
self._splitter.addWidget(self._controls)
self._splitter.setSizes([1200, 600])
# Main window layout
self.setCentralWidget(self._splitter)
# Connect controls to handlers
self._controls.ok.clicked.connect(self.ok)
self._controls.cancel.clicked.connect(self.cancel)
self._controls.inbox.choose_directory.clicked.connect(
self.choose_inbox)
self._controls.processed.choose_directory.clicked.connect(
self.choose_processed)
# Directories
mydocuments = QDesktopServices.storageLocation(
QDesktopServices.DocumentsLocation)
self._inbox = Path(QSettings().value('inbox',
str(Path(mydocuments) / 'inbox')))
self._processed = Path(QSettings().value(
'processed', str(Path(mydocuments) / 'processed')))
self._controls.inbox.set_link(str(self._inbox.as_uri()),
self._inbox.name)
self._controls.processed.set_link(str(self._processed.as_uri()),
self._processed.name)
# A stack of Path objects to be processed
self._pending_files = []
# The Path currently shown in the UI
self._under_review = None
# Watch the inbox directory, if it exists
self.new_pending_files.connect(self.process_next_pending,
QtCore.Qt.QueuedConnection)
if self._inbox.is_dir():
self._watcher = NewFileWatcher(self._inbox, IMAGE_SUFFIXES_RE)
self._watcher.new_file.connect(self.new_image_file)
else:
self._watcher = None
self.empty_controls()
# Setup drag-drop handling
self.setAcceptDrops(True)
self._controls.installEventFilter(self)
self._splitter.installEventFilter(self)
def createWidgets(self):
settings = QSettings()
self.txtGroupBox = QGroupBox("Plain Text Format (.txt)")
self.indentLabel = QLabel("&Indent")
self.indentComboBox = QComboBox()
self.indentLabel.setBuddy(self.indentComboBox)
oldIndent = IndentKind.TAB
oldIndent = self.config.get(Gconf.Key.Indent, oldIndent)
index = -1
for i, indent in enumerate(IndentKind):
text = indent.name.replace("_", " ").title()
self.indentComboBox.addItem(text, indent.value)
if indent is oldIndent:
index = i
self.indentComboBox.setCurrentIndex(index)
self.form.tooltips.append((self.indentComboBox, """\
<p><b>Indent</b></p>
<p>The indentation to use when outputting an indented-style index in
plain text format for each level of indentation.</p>"""))
self.rtfGroupBox = QGroupBox("Rich Text Format (.rtf)")
self.rtfIndentLabel = QLabel("I&ndent")
self.rtfIndentComboBox = QComboBox()
self.rtfIndentLabel.setBuddy(self.rtfIndentComboBox)
oldIndent = IndentKind(int(settings.value(Gopt.Key.IndentRTF,
Gopt.Default.IndentRTF)))
index = -1
for i, indent in enumerate(IndentKind):
text = ("Indent" if i == 0 else
indent.name.replace("_", " ").title())
self.rtfIndentComboBox.addItem(text, indent.value)
if indent is oldIndent:
index = i
self.rtfIndentComboBox.setCurrentIndex(index)
self.form.tooltips.append((self.rtfIndentComboBox, """\
<p><b>Indent</b></p>
<p>The indentation to use when outputting an indented-style index in
rich text format for each level of indentation.</p>"""))
self.pdfGroupBox = QGroupBox("Portable Document Format (.pdf)")
self.paperSizeLabel = QLabel("Paper Size")
self.letterRadioButton = QRadioButton("&Letter")
self.a4RadioButton = QRadioButton("&A4")
size = PaperSizeKind(int(settings.value(Gopt.Key.PaperSize,
Gopt.Default.PaperSize)))
if size is PaperSizeKind.LETTER:
self.letterRadioButton.setChecked(True)
else:
self.a4RadioButton.setChecked(True)
self.form.tooltips.append((self.letterRadioButton, """\
<p><b>Paper Size, Letter</b></p>
<p>If checked, when outputting a PDF of the index, US Letter
8.5"x11"-sized pages will be used.</p>"""))
self.form.tooltips.append((self.a4RadioButton, """\
<p><b>Paper Size, A4</b></p>
<p>If checked, when outputting a PDF of the index, European A4-sized
pages will be used.</p>"""))
def menuHovered(self, action):
settings = QSettings()
if bool(
int(
settings.value(Gopt.Key.ShowMenuToolTips,
Gopt.Default.ShowMenuToolTips))):
tip = action.toolTip()
if tip:
QToolTip.showText(QCursor.pos(), tip, self)
def load(self, call, limit=None):
"""
Load a stream.
call is the stream to load (see
retriever.py:KhweeteurRefreshWorker for a description of the
possible values).
limit is the maximum number of messages to show. If the
number of messages exceeds limit, then selects the newest
messages (in terms of creation time, not download time).
Returns whether the load loaded a new data set (True) or was
just a reload (False).
"""
self.now = time.time()
# print "model.load(%s -> %s)" % (self.call, call)
# new_message_horizon is the point in time that separates read
# messages from new messages. The messages' creation time is
# used.
settings = QSettings('Khertan Software', 'Khweeteur')
if self.call != call:
# It's not a reload. Save the setting for the old stream
# and load the setting for the new one.
reloading = True
self.save_config()
try:
self.new_message_horizon = int(
settings.value(call + '-new-message-horizon', 0))
except (ValueError, TypeError) :
self.new_message_horizon = self.now
# There might be some useful avatars, but figuring out
# which they are requires loading all of the status
# updates.
self.avatars = {}
else:
reloading = False
self.nothing_really_loaded = False
self.call = call
self.avatar_path = os.path.join(os.path.expanduser('~'), '.khweeteur',
'avatars')
folder = self.getCacheFolder()
try:
self.uids = os.listdir(folder)
except (IOError, EOFError, OSError), e:
if e.errno != errno.ENOENT:
logging.exception('listdir(%s): %s' % (folder, str(e)))
self.uids = []
def QloadParameter(paramName, quiet=False):
from PySide.QtCore import QSettings
settings = QSettings("TCfA", "CPEDS")
paramValue = settings.value(paramName)
if quiet == False:
print('loading Qparameter: %s' % paramName)
print(' parameter value: ', paramValue)
return paramValue
def __init__(self):
self.dirFile = '.'
self.frequency = 30.
self._settings = QSettings('Ear to Ear Oak', 'ebbbe')
self.dirFile = self._settings.value('dirFile', self.dirFile)
self.frequency = float(
self._settings.value('frequency', self.frequency))
def _getLanguageAndRules(self):
settings = QSettings()
language = LanguageKind(
settings.value(Gopt.Key.Language, Gopt.Default.Language))
sortAsRules = settings.value(Gopt.Key.SortAsRules,
Gopt.Default.SortAsRules)
pageRangeRules = settings.value(Gopt.Key.PageRangeRules,
Gopt.Default.PageRangeRules)
return language, sortAsRules, pageRangeRules
def _acceptOptions(self):
settings = QSettings()
size = PaperSizeKind.A4
if self.specificOutputPanel.letterRadioButton.isChecked():
size = PaperSizeKind.LETTER
settings.setValue(Gopt.Key.PaperSize, int(size))
if self.state.printer is not None:
self.state.printer.setPaperSize(
QPrinter.A4 if size is PaperSizeKind.A4 else QPrinter.Letter)
def save_config(self, lazily=True):
logging.debug("%s.save_config(%s) (nothing really loaded: %s)",
self.call, lazily, self.nothing_really_loaded)
if not self.nothing_really_loaded:
settings = QSettings('Khertan Software', 'Khweeteur')
settings.setValue(
self.call + '-new-message-horizon', self.max_created_at)
self.save_data_cache(lazily)
def accept(self):
settings = QSettings()
settings.setValue("DB/File", self.file.text())
settings.setValue("SMTP/Server", self.smtp_server.text())
settings.setValue("HTTP Proxy/IP", self.http_proxy_ip.text())
settings.setValue(
"HTTP Proxy/Enabled",
bool(self.http_proxy.isChecked())
and bool(self.http_proxy_ip.text()))
QDialog.accept(self)
def loadLastUpdateCheckDate(self):
settings = QSettings("Syncplay", "Interface")
settings.beginGroup("Update")
self.lastCheckedForUpdates = settings.value("lastChecked", None)
if self.lastCheckedForUpdates:
if self.config["lastCheckedForUpdates"] is not None and self.config["lastCheckedForUpdates"] is not "":
if self.lastCheckedForUpdates > datetime.strptime(self.config["lastCheckedForUpdates"], "%Y-%m-%d %H:%M:%S.%f"):
self.config["lastCheckedForUpdates"] = str(self.lastCheckedForUpdates)
else:
self.config["lastCheckedForUpdates"] = str(self.lastCheckedForUpdates)
def __init__(self, open_file_slot, key, menu):
self.open_file_slot = open_file_slot
self.settings_key = key
self.menu = menu
settings = QSettings()
file_list = settings.value(key)
if file_list is not None:
for file_name in file_list:
self.append(RecentFile(file_name, self.open_file_slot))
self.update()
def accept(self):
settings = QSettings()
settings.setValue("DB/File", self.file.text())
settings.setValue("SMTP/Server", self.smtp_server.text())
settings.setValue("HTTP Proxy/IP", self.http_proxy_ip.text())
settings.setValue("HTTP Proxy/Enabled", bool(self.http_proxy.isChecked()) and bool(self.http_proxy_ip.text()))
QDialog.accept(self)
def add_path(self, path):
"Adds path to recent documents"
recent = self.read_paths()
# Make the path absolute, resolving any symlinks.
path = self._resolved_if_possible(Path(path))
# Remove the existing occurrence of path, if present.
# A linear scan is acceptable here because the list will always
# be very short
try:
recent.remove(path)
except ValueError:
# path is not currently in recent
pass
# Prepend the path
recent.insert(0, str(path))
# Limit to MAX_RECENT_DOCS
recent = recent[:self.MAX_RECENT_DOCS]
debug_print('Writing {0} recent document paths'.format(len(recent)))
settings = QSettings()
settings.beginWriteArray(self.KEY, len(recent))
try:
for index, path in enumerate(recent):
settings.setArrayIndex(index)
settings.setValue('path', str(path))
finally:
settings.endArray()
class MainWindow(QtGui.QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.setWindowTitle("supervisor Interface")
self.__mutex__ = QtCore.QMutex()
self.__log__()
self.__setting__()
self.createActions()
self.createMenus()
self.__rpc__ = None
self.centralWidget = CentralWidget(None, (self.settings, self.__mutex__) )
self.statusBar().showMessage("Ready")
def __setting__(self):
print "get setting"
#self.settings = QSettings(QSettings.IniFormat,QSettings.SystemScope, '__ILLUSTRABOT2OO', '__settings')
self.settings = QSettings(QSettings.IniFormat,QSettings.UserScope, '__ILLUSTRABOT2OO', '__settings')
self.settings.setFallbacksEnabled(False) # File only, not registry or or.
self.__mutex__.lock()
self.settings.beginGroup("Main")
self.resize(self.settings.value("size", QtCore.QSize(1024, 850)))
self.move(self.settings.value("pos", QtCore.QPoint(50, 50)))
self.ip = self.settings.value("ip", r'172.25.195.58')
print "previous IP=",self.ip
self.settings.endGroup()
self.__mutex__.unlock()
def __log__(self):
self.windowlog = {}
def rpc(self):
# Try to connect to a board
print self.ip
text, ok = QtGui.QInputDialog.getText(self, self.tr("Board IP"),
self.tr("IP address:"), QtGui.QLineEdit.Normal,
self.ip)
if ok and not (len(text) ==0):
try:
self.__rpc__ = xmlrpclib.ServerProxy("http://%s:8000"%str(text))
self.statusBar().showMessage("Connected...")
self.centralWidget.setrpc(self.__rpc__)
self.__get_level__()
self.setCentralWidget(self.centralWidget)
self.ip= str(text)
except Exception,e:
self.statusBar().showMessage("Failed to connect to %s"%text)
sys.stderr.write( str(e))
traceback.print_exc(file=sys.stderr)
pass
return
class Box2dBodySettings(QWidget, Ui_Box2dBodySettings):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, COMPANY, APPNAME)
self.restoreGeometry(self.settings.value(self.__class__.__name__))
def closeEvent(self, e):
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, COMPANY, APPNAME)
self.settings.setValue(self.__class__.__name__, self.saveGeometry())
def __init__(self, *args, **kwargs):
QApplication.__init__(self, *args, **kwargs)
self.settings = QSettings('everpad', 'everpad-pad')
self.translator = QTranslator()
if not self.translator.load('../../i18n/%s' % QLocale.system().name()):
self.translator.load('/usr/share/everpad/i18n/%s' %
QLocale.system().name())
self.installTranslator(self.translator)
self.indicator = Indicator(self)
self.update_icon()
self.indicator.show()
def __init__(self, parent=None):
super(SettingsDialog, self).__init__(parent)
self.setWindowTitle("Settings")
main_layout = QVBoxLayout()
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
settings = QSettings()
db_group = QGroupBox("Database")
grid_layout = QGridLayout()
grid_layout.addWidget(QLabel("File"),0,0)
text = settings.value('DB/File')
self.file = QLineEdit(text)
self.file.setText(text)
grid_layout.addWidget(self.file,0,1)
browse = QPushButton("Browse")
browse.clicked.connect(self.browse)
grid_layout.addWidget(browse,0,2)
db_group.setLayout(grid_layout)
main_layout.addWidget(db_group)
ip_width = QFontMetrics(QFont(self.font())).width("000.000.000.000 ")
smtp_group = QGroupBox("SMTP")
grid_layout = QGridLayout()
grid_layout.addWidget(QLabel("Server"),0,0)
text = settings.value('SMTP/Server')
self.smtp_server = QLineEdit(text)
self.smtp_server.setText(text)
grid_layout.addWidget(self.smtp_server,0,1)
smtp_group.setLayout(grid_layout)
main_layout.addWidget(smtp_group)
self.http_proxy = QGroupBox("HTTP Proxy")
self.http_proxy.setCheckable(True)
self.http_proxy.setChecked(bool(settings.value('HTTP Proxy/Enabled')))
grid_layout = QGridLayout()
grid_layout.addWidget(QLabel("Server"),0,0)
self.http_proxy_ip = QLineEdit()
self.http_proxy_ip.setText(settings.value('HTTP Proxy/IP'))
self.http_proxy_ip.setMinimumWidth(ip_width)
grid_layout.addWidget(self.http_proxy_ip,0,1)
grid_layout.setColumnStretch(0,1)
self.http_proxy.setLayout(grid_layout)
main_layout.addWidget(self.http_proxy)
main_layout.addWidget(buttonBox)
self.setLayout(main_layout)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
def update_settings(new_settings):
"""Updates settings. new_settings should be a dict:
{
"engine": one of ('libdmtx', 'zbar', 'inlite'),
"inlite-format": one of ('1d', 'datamatrix', 'pdf417', 'qrcode'),
}
"""
debug_print('New barcode settings', new_settings)
s = QSettings()
s.setValue('barcode/engine', new_settings['engine'])
s.setValue('barcode/inlite-format', new_settings['inlite-format'])
def showOrHideSortAs(self):
settings = QSettings()
alwaysShowSortAs = bool(
int(
settings.value(Gopt.Key.AlwaysShowSortAs,
Gopt.Default.AlwaysShowSortAs)))
editable = not self.calcSortAsCheckBox.isChecked()
visible = alwaysShowSortAs or editable
for widget in (self.sortAsLabel, self.sortAsEdit):
widget.setVisible(visible)
widget.setEnabled(editable)
def current_settings():
"""Returns a dict of the current settings:
{
"engine": one of ('libdmtx', 'zbar', 'inlite'),
"inlite-format": one of ('1d', 'datamatrix', 'pdf417', 'qrcode'),
}
"""
s = QSettings()
return {
'engine': s.value('barcode/engine', 'libdmtx'),
'inlite-format': s.value('barcode/inlite-format', 'datamatrix')
}
def readSettings(self):
settings = QSettings()
self.restoreGeometry(settings.value("main/geometry"))
self.restoreState(settings.value("main/windowState"))
self.environmentDock.readSettings()
self.debugDock.readSettings()
if not self.runningFile:
self.runningFile = settings.value("main/currentFile")
print(self.runningFile)
QtCore.QTimer.singleShot(0, self, QtCore.SLOT("reloadMoai()"))
def show_from_geometry_settings(self):
print('MainWindow.show_from_geometry_settings')
# TODO LH What if screen resolution, desktop config change or roaming
# profile means that restored state is outside desktop?
s = QSettings()
self.restoreGeometry(s.value("mainwindow/geometry", self.saveGeometry()))
if not (self.isMaximized() or self.isFullScreen()):
self.move(s.value("mainwindow/pos", self.pos()))
self.resize(s.value("mainwindow/size", self.size()))
self.show()
def __init__(self, parent, mItem=None):
super(PreferenceDialog, self).__init__(parent)
self.setWindowTitle(self.tr("Preferences"))
layout = QVBoxLayout(self)
modelLayout = QHBoxLayout()
settings = QSettings()
#startup
startupCheck = QCheckBox(self.tr("Launch at startup"))
autoStart = os.path.exists(os.path.join(util.configDir, 'autostart', 'kpremap-server.desktop'))
startupCheck.setChecked(autoStart)
startupCheck.stateChanged.connect(self.slotAutoStart)
#auto update
updateCheck = QCheckBox(self.tr("Automatically update the server"))
autoUpdate = util.str2bool(settings.value('autoUpdate', 'true'))
updateCheck.setChecked(autoUpdate)
updateCheck.stateChanged.connect(self.slotAutoUpdate)
#notiny
notifyCheck = QCheckBox(self.tr("Show notification"))
notify = parent.mapping().notify()
notifyCheck.setChecked(notify)
notifyCheck.stateChanged.connect(self.slotNotify)
#model
self.comboModel = QComboBox()
modList = ((self.tr('Generic 101'), 'generic_101'),
(self.tr('Generic 102'), 'generic_102'),
(self.tr('Generic 104'), 'generic_104'),
(self.tr('Generic 105'), 'generic_105'),
('TypeMatrix', 'typeMatrix'),
)
for title, name in modList:
self.comboModel.addItem(title, name)
currentModel = settings.value('keyboardModel', 'generic_105')
index = self.comboModel.findData(currentModel)
self.comboModel.setCurrentIndex(index)
self.comboModel.currentIndexChanged.connect(self.slotModel)
modelLayout.addWidget(QLabel(self.tr("keyboard model:")))
modelLayout.addWidget(self.comboModel)
buttonBox = QDialogButtonBox(QDialogButtonBox.Close,
rejected=self.reject)
layout.addWidget(startupCheck)
layout.addWidget(updateCheck)
layout.addWidget(notifyCheck)
layout.addLayout(modelLayout)
layout.addWidget(Separator())
layout.addWidget(buttonBox)
def add_file(self, file_name):
item = RecentFile(file_name, self.open_file_slot)
if (len(self) > 0) and (self[0] == item):
return # No action; it's already there
if item in self:
self.remove(item) # it might be later in the list
self.insert(0, item) # make it the first in this list
if len(self) > 10:
self[:] = self[:10]
# List changed, so save it to the registry
settings = QSettings()
file_list = [x.file_name for x in self]
settings.setValue(self.settings_key, file_list)
self.update()
def writeSettings(self):
settings = QSettings(
QSettings.IniFormat, QSettings.UserScope, "SparseBoolean", "Android Develop and Test Assistant"
)
disabledPlugins = []
forceEnabledPlugins = []
for spec in self.pluginSpecs:
if not spec.isExperimental() and not spec.isEnabled():
disabledPlugins.append(spec.name())
if spec.isExperimental() and spec.isEnabled():
forceEnabledPlugins.append(spec.name())
settings.setValue(IGNORED_PLUGINS, disabledPlugins)
settings.setValue(FORCEENABLED_PLUGINS, forceEnabledPlugins)
class CropWidget(QWidget, Ui_CropWindow):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, COMPANY, APPNAME)
self.restoreGeometry(self.settings.value(self.__class__.__name__))
self.images = []
if len(sys.argv) > 1:
d = QDir(path=sys.argv[1])
else:
d = QDir(path=QFileDialog.getExistingDirectory())
d.setNameFilters(['*.png'])
d.setFilter(QDir.Files or QDir.NoDotAndDotDot)
d = QDirIterator(d)
images = []
while d.hasNext():
images.append(d.next())
for i in images:
print i
self.images = [QImage(i) for i in images]
self.images += [crop_image_from_file(i, 50)[0] for i in images]
def keyPressEvent(self, e):
if e.key() == Qt.Key_Escape:
self.close()
def paintEvent(self, e):
painter = QPainter(self)
painter.setWorldTransform(QTransform().scale(0.5, 0.5))
x = 0
for i in self.images:
painter.drawImage(QRect(x, 0, i.width(), i.height()), i)
painter.drawRect(x, 0, i.width(), i.height())
x += i.width()
def closeEvent(self, e):
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, COMPANY, APPNAME)
self.settings.setValue(self.__class__.__name__, self.saveGeometry())
def __init__(self, ):
QObject.__init__(self)
self._settings = QSettings()
self._token = ''
self._timeremaining = ''
self._serial = ''
if self._settings.contains('REGION'):
self._region = self._settings.value('REGION')
if self._region not in ('EU', 'US'):
self._set_region('US')
else:
self._region = 'US'
if self._settings.contains('SECRET'):
self._secret = unhexlify(self._settings.value('SECRET'))
if not self._secret:
self.new_serial()
else:
self.new_serial()
if not self._serial:
if self._settings.contains('SERIAL'):
self._serial = self._settings.value('SERIAL')
if self._token == '':
self.sync()
def setUp(self):
self.settings = QSettings('com.nokia.qt.serviceframework.tests',
'SampleServicePlugin')
self.manager = QServiceManager()
self.serviceXml = os.path.join(os.path.dirname(__file__),
'sampleservice.xml')
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, COMPANY, APPNAME)
self.restoreGeometry(self.settings.value(self.__class__.__name__))
self.images = []
if len(sys.argv) > 1:
d = QDir(path=sys.argv[1])
else:
d = QDir(path=QFileDialog.getExistingDirectory())
d.setNameFilters(['*.png'])
d.setFilter(QDir.Files or QDir.NoDotAndDotDot)
d = QDirIterator(d)
images = []
while d.hasNext():
images.append(d.next())
for i in images:
print i
self.images = [QImage(i) for i in images]
self.images += [crop_image_from_file(i, 50)[0] for i in images]
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.current_directory = None
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, COMPANY, APPNAME)
self.restoreGeometry(self.settings.value(self.__class__.__name__))
self.splitter.restoreState(self.settings.value(SPLITTER))
self.current_directory = self.settings.value(CURRENT_DIRECTORY)
self.white_albatross = WhiteAlbatrossWidget()
self.white_albatross.figuresChanged.connect(self.on_figures_changed)
self.workLayout.insertWidget(1, self.white_albatross)
self.type.currentIndexChanged.connect(self.white_albatross.setType)
self.type.setCurrentIndex(int(self.settings.value(LAST_FIGURE_TYPE, defaultValue=0)))
self.addImages.clicked.connect(self.add_images_click)
self.openFolder.clicked.connect(self.open_folder_clicked)
self.removeImages.clicked.connect(self.remove_images)
self.imagesList.itemSelectionChanged.connect(self.item_selected)
self.deleteFigure.clicked.connect(self.delete_figure)
self.figures.customContextMenuRequested.connect(self.figures_context_menu)
if self.current_directory:
self.open_folder()
self.imagesList.setCurrentRow(int(self.settings.value(SELECTED_IMAGE, defaultValue=0)))
