def viewInBrowser(self):
dstPath = os.path.join(TemporaryDir.path(), Settings()['template'] + '.htm')
report = Report(self.model(), Settings()['template'], dstPath, self)
indexes = self.selectedRows()
fileName = report.generate(indexes)
if fileName:
executor = QDesktopServices()
executor.openUrl(QtCore.QUrl.fromLocalFile(fileName))
def save(self):
settings = Settings()
settings['colnect_enabled'] = self.enabledGroup.isChecked()
settings['colnect_locale'] = self.languageSelector.currentData()
settings['colnect_autoclose'] = self.autoclose.isChecked()
settings['colnect_skip_currency'] = self.skip_currency.isChecked()
settings.save()
def save(self):
settings = Settings()
settings['colnect_enabled'] = self.enabledGroup.isChecked()
settings['colnect_locale'] = self.languageSelector.currentData()
settings['colnect_autoclose'] = self.autoclose.isChecked()
settings['colnect_skip_currency'] = self.skip_currency.isChecked()
settings.save()
def contextMenu(self, pos):
open_ = QAction(self.tr("Open"), self)
open_.triggered.connect(self.openImage)
use_external_viewer = not Settings()['built_in_viewer']
if use_external_viewer:
edit = QAction(self.tr("Edit..."), self)
edit.triggered.connect(self.editImage)
copy = QAction(self.tr("Copy"), self)
copy.triggered.connect(self.copyImage)
copy.setDisabled(self.image.isNull())
save = QAction(self.tr("Save as..."), self)
save.triggered.connect(self.saveImage)
save.setDisabled(self.image.isNull())
menu = QMenu()
menu.addAction(open_)
menu.setDefaultAction(open_)
if use_external_viewer:
menu.addAction(edit)
menu.addAction(save)
menu.addSeparator()
menu.addAction(copy)
menu.exec_(self.mapToGlobal(pos))
def __init__(self, treeParam, parent=None):
super().__init__(parent)
self.show_tree_icons = treeParam.show_tree_icons
self.convert_fraction = treeParam.convert_fraction
self.setHeaderHidden(True)
self.setAutoScroll(False)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.contextMenuEvent)
self.currentItemChanged.connect(self.itemActivatedEvent)
self.itemExpanded.connect(self.expandedEvent)
self.collapsed.connect(self.collapsedEvent)
self.treeParam = treeParam
# Changing of TreeView is enabled (by signals from model or ListView)
self.changingEnabled = True
locale = Settings()['locale']
self.collator = QCollator(QLocale(locale))
self.collator.setNumericMode(True)
self.setItemDelegate(AutoToolTipDelegate())
def setData(self, xx, yy, region):
data = ','.join(["['%s', %d]" % (x, y) for x, y in zip(xx, yy)])
header = "['%s', '%s']" % (self.tr("Country"), self.tr("Number of coins"))
data = ','.join((header, data))
locale = Settings()['locale']
self.html_data = self.HTML % (locale, region, data)
self.setHtml(self.html_data, QUrl.fromLocalFile(OpenNumismat.PRJ_PATH))
def viewInBrowser(self, indexes=None):
if not indexes:
indexes = self.selectedRows()
records = []
for index in indexes:
records.append(self.model().record(index.row()))
dstPath = os.path.join(TemporaryDir.path(),
Settings()['template'] + '.htm')
report = Report(self.model(), Settings()['template'], dstPath)
fileName = report.generate(records)
if fileName:
executor = QDesktopServices()
executor.openUrl(QtCore.QUrl.fromLocalFile(fileName))
def __init__(self, is_static, parent):
super().__init__(parent)
self.language = Settings()['locale']
self.is_static = is_static
self.lat = None
self.lng = None
self.points = []
self.activated = False
self.initialized = False
self.loadFinished.connect(self.onLoadFinished)
if importedQtWebEngine:
self.setPage(WebEnginePage(self))
channel = QWebChannel(self.page())
channel.registerObject("qtWidget", self)
self.page().setWebChannel(channel)
else:
self.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.page().linkClicked.connect(self.linkClicked)
self.page().mainFrame().addToJavaScriptWindowObject(
"qtWidget", self)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
def mapLayout(self):
layout = BaseFormLayout()
layout.addRow(self.items['address'])
layout.addRow(self.items['latitude'], self.items['longitude'])
coordinates_enabled = not (self.items['latitude'].isHidden()
or self.items['longitude'].isHidden())
if importedQtWebKit and coordinates_enabled:
settings = Settings()
if settings['map_type'] == 0 or not gmapsAvailable:
self.map_item = OSMWidget(self)
else:
self.map_item = GMapsWidget(self)
self.map_item.markerMoved.connect(self.mapMarkerMoved)
self.map_item.markerRemoved.connect(self.mapMarkerRemoved)
layout.addWidget(self.map_item, layout.row, 0, 1,
layout.columnCount)
self.items['address'].widget().findClicked.connect(
self.map_item.geocode)
self.items['latitude'].widget().textChanged.connect(
self.mapChanged)
self.items['longitude'].widget().textChanged.connect(
self.mapChanged)
return layout
def __init__(self, parent=None):
super().__init__(parent)
self.setDynamicSortFilter(True)
locale = Settings()['locale']
self.collator = QCollator(QLocale(locale))
self.collator.setNumericMode(True)
def openImage(self):
if Settings()['built_in_viewer']:
self.editImage()
else:
fileName = self._saveTmpImage()
executor = QDesktopServices()
executor.openUrl(QUrl.fromLocalFile(fileName))
def setData(self, xx, yy, region):
data = ','.join(["['%s', %d]" % (x, y) for x, y in zip(xx, yy)])
header = "['%s', '%s']" % (self.tr("Country"),
self.tr("Number of coins"))
data = ','.join((header, data))
locale = Settings()['locale']
self.html_data = self.HTML % (locale, MAPS_API_KEY, region, data)
self.setHtml(self.html_data)
def save(self):
settings = Settings()
settings['locale'] = self.languageSelector.currentData()
settings['backup'] = self.backupFolder.text()
settings['autobackup'] = self.autobackup.isChecked()
settings['autobackup_depth'] = self.autobackupDepth.value()
settings['reference'] = self.reference.text()
settings['error'] = self.errorSending.isChecked()
settings['updates'] = self.checkUpdates.isChecked()
settings['speedup'] = self.speedup.currentData()
settings['template'] = self.templateSelector.currentData()
settings['check_coin_title'] = self.checkTitle.isChecked()
settings['check_coin_duplicate'] = self.checkDuplicate.isChecked()
settings['images_by_default'] = self.imagesByDefault.value()
settings['map_type'] = self.mapSelector.currentIndex()
settings.save()
def save(self):
settings = Settings()
settings['locale'] = self.languageSelector.currentData()
settings['backup'] = self.backupFolder.text()
settings['autobackup'] = self.autobackup.isChecked()
settings['autobackup_depth'] = self.autobackupDepth.value()
settings['reference'] = self.reference.text()
settings['error'] = self.errorSending.isChecked()
settings['updates'] = self.checkUpdates.isChecked()
settings['speedup'] = self.speedup.currentData()
settings['template'] = self.templateSelector.currentData()
settings['check_coin_title'] = self.checkTitle.isChecked()
settings['check_coin_duplicate'] = self.checkDuplicate.isChecked()
settings['images_by_default'] = self.imagesByDefault.value()
settings['map_type'] = self.mapSelector.currentIndex()
settings['verify_ssl'] = self.verifySsl.isChecked()
settings.save()
def __saveParams(self):
if self.collection.isOpen():
for param in self.collection.pages().pagesParam():
param.listParam.save_lists(only_if_changed=True)
self.viewTab.savePagePositions(only_if_changed=True)
if Settings()['autobackup']:
if self.collection.isNeedBackup():
self.collection.backup()
def __init__(self, pageParam, parent=None):
super().__init__('0', parent=parent)
self.imagesAtBottom = pageParam.images_at_bottom
self._model = None
self.param = pageParam
self.id = pageParam.id
self.treeView = TreeView(pageParam.treeParam, self)
if self.param.type == CollectionPageTypes.Card:
self.listView = CardView(self.param.listParam, self)
elif self.param.type == CollectionPageTypes.Icon:
self.listView = IconView(self.param.listParam, self)
else:
self.listView = ListView(self.param.listParam, self)
if self.imagesAtBottom:
self.imageView = ImageView(QBoxLayout.LeftToRight, self)
self.detailsView = DetailsView(QBoxLayout.TopToBottom, self)
else:
self.imageView = ImageView(QBoxLayout.TopToBottom, self)
self.detailsView = DetailsView(QBoxLayout.LeftToRight, self)
self.splitter1 = Splitter('1', Qt.Vertical, self)
splitter2 = Splitter('2', parent=self.splitter1)
splitter2.addWidget(self.treeView)
splitter2.addWidget(self.listView)
self.splitter1.addWidget(splitter2)
if self.imagesAtBottom:
self.splitter1.addWidget(self.imageView)
else:
self.splitter1.addWidget(self.detailsView)
if statisticsAvailable:
self.statisticsView = StatisticsView(pageParam.statisticsParam)
self.statisticsView.setMinimumHeight(200)
if importedQtWebKit:
settings = Settings()
if settings['map_type'] == 0 or not gmapsAvailable:
self.mapView = GlobalOSMWidget()
else:
self.mapView = GlobalGMapsWidget()
self.mapView.markerClicked.connect(self.setCurrentCoin)
self.addWidget(self.splitter1)
if self.imagesAtBottom:
self.addWidget(self.detailsView)
else:
self.addWidget(self.imageView)
self.listView.rowChanged.connect(self.imageView.rowChangedEvent)
self.listView.rowChanged.connect(self.treeView.rowChangedEvent)
self.listView.rowChanged.connect(self.detailsView.rowChangedEvent)
self.splitterMoved.connect(self.splitterPosChanged)
def autoUpdate(self):
if Settings()['updates']:
settings = QSettings()
lastUpdateDateStr = settings.value('mainwindow/last_update')
if lastUpdateDateStr:
lastUpdateDate = QDate.fromString(lastUpdateDateStr,
Qt.ISODate)
currentDate = QDate.currentDate()
if lastUpdateDate.addDays(10) < currentDate:
self.checkUpdates()
else:
self.checkUpdates()
def __init__(self, collection, parent=None):
super().__init__(parent)
settings = Settings()
fLayout = QFormLayout()
fLayout.setRowWrapPolicy(QFormLayout.WrapLongRows)
default_locale = settings['colnect_locale']
current = 9
self.languageSelector = QComboBox(self)
for i, lang in enumerate(self.Languages):
self.languageSelector.addItem(lang[1], lang[0])
if default_locale == lang[0]:
current = i
self.languageSelector.setCurrentIndex(current)
self.languageSelector.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.Fixed)
fLayout.addRow(self.tr("Language"), self.languageSelector)
self.autoclose = QCheckBox(self.tr("Close dialog after adding item"),
self)
self.autoclose.setChecked(settings['colnect_autoclose'])
fLayout.addRow(self.autoclose)
self.skip_currency = QCheckBox(self.tr("Skip currency symbol"),
self)
self.skip_currency.setChecked(settings['colnect_skip_currency'])
fLayout.addRow(self.skip_currency)
clearCacheBtn = QPushButton(self.tr("Clear cache"), self)
clearCacheBtn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
clearCacheBtn.clicked.connect(self.clearCache)
hLayout = QHBoxLayout()
hLayout.addWidget(clearCacheBtn, alignment=Qt.AlignRight)
vLayout = QVBoxLayout()
vLayout.addLayout(fLayout)
vLayout.addLayout(hLayout)
self.enabledGroup = QGroupBox(self.tr("Use Colnect"), self)
self.enabledGroup.setCheckable(True)
self.enabledGroup.setChecked(settings['colnect_enabled'])
self.enabledGroup.setLayout(vLayout)
layout = QVBoxLayout()
layout.addWidget(self.enabledGroup)
self.setLayout(layout)
def mapLayout(self):
self.map_item = None
coordinates_enabled = not (self.items['latitude'].isHidden() or
self.items['longitude'].isHidden())
if importedQtWebKit and coordinates_enabled:
settings = Settings()
if settings['map_type'] == 0 or not gmapsAvailable:
self.map_item = StaticOSMWidget(self)
else:
self.map_item = StaticGMapsWidget(self)
return self.map_item
def exceptHook(type_, value, tback):
stack = ''.join(traceback.format_exception(type_, value, tback))
title = QApplication.translate("ExcpHook", "System error")
text = QApplication.translate(
"ExcpHook", "A system error occurred.\n"
"Do you want to send an error message to the author?")
msgBox = QMessageBox(QMessageBox.Information, title, text)
msgBox.setDetailedText(stack)
msgBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
if msgBox.exec_() == QMessageBox.Yes:
line = traceback.extract_tb(tback)[-1]
subject = "[v%s] %s - %s:%d" % (version.Version, type_.__name__,
line[0], line[1])
errorMessage = []
# errorMessage.append(QApplication.translate(
# "ExcpHook",
# "PLEASE ADD A COMMENT, IT WILL HELP IN SOLVING THE PROBLEM"))
# errorMessage.append('')
errorMessage.append("%s: %s" % (version.AppName, version.Version))
errorMessage.append(
"OS: %s %s (%s)" %
(platform.system(), platform.release(), platform.version()))
errorMessage.append(
"Python: %s (%s)" %
(platform.python_version(), platform.architecture()[0]))
errorMessage.append("Qt: %s" % PYQT_VERSION_STR)
try:
errorMessage.append("Locale: %s" % Settings()['locale'])
except:
pass
errorMessage.append('')
errorMessage.append(stack)
url = QUrl('http://opennumismat.idea.informer.com/proj/')
query = QUrlQuery()
query.addQueryItem('mod', 'add')
query.addQueryItem('cat', '3')
query.addQueryItem('idea', subject)
query.addQueryItem('descr', '\n'.join(errorMessage))
url.setQuery(query)
executor = QDesktopServices()
executor.openUrl(url)
# Call the default handler
sys.__excepthook__(type_, value, tback)
def __init__(self, parent):
super().__init__(parent,
Qt.WindowCloseButtonHint | Qt.WindowSystemMenuHint)
if Settings()['locale'] == 'fr':
self.language = Settings()['locale']
else:
self.language = 'en'
self.page = QWebView(self)
if importedQtWebEngine:
self.page.setPage(WebEnginePage(self))
else:
self.page.linkClicked.connect(self.onLinkClicked)
self.page.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.page.urlChanged.connect(self.onUrlChanged)
redirect_uri = 'local' # Should normally be a URL to your application
url_template = ('https://{language}.numista.com/api/oauth_authorize.php'
'?response_type=code'
'&client_id={client_id}'
'&redirect_uri={redirect_uri}'
'&scope={scope}')
authorization_url = url_template.format(
language=self.language,
client_id='opennumismat',
redirect_uri=redirect_uri,
scope='view_collection')
self.page.load(QUrl(authorization_url))
layout = QVBoxLayout()
layout.addWidget(self.page)
layout.setContentsMargins(QMargins())
self.setLayout(layout)
self.setWindowTitle(self.tr("Numista"))
def __init__(self, is_static, parent):
super().__init__(parent)
self.language = Settings()['locale']
self.is_static = is_static
self.lat = None
self.lng = None
self.points = []
self.activated = False
self.initialized = False
self.loadFinished.connect(self.onLoadFinished)
self.page().mainFrame().addToJavaScriptWindowObject("qtWidget", self)
self.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.page().linkClicked.connect(self.linkClicked)
def setModel(self, model):
model.rowInserted.connect(self.rowInserted)
self.proxyModel = SortFilterProxyModel(self)
self.proxyModel.setSourceModel(model)
super(ListView, self).setModel(self.proxyModel)
model.proxy = self.proxyModel
self.headerButtons = []
for param in self.listParam.columns:
btn = FilterMenuButton(param, self.listParam, self.model(),
self.horizontalHeader())
self.headerButtons.append(btn)
filtersSql = FilterMenuButton.filtersToSql(
self.listParam.filters.values())
self.model().setFilter(filtersSql)
self.horizontalHeader().sectionResized.disconnect(self.columnResized)
self._moveColumns()
for i in range(model.columnCount()):
self.hideColumn(i)
apply_sorting = Settings()['store_sorting']
for param in self.listParam.columns:
if param.enabled:
self.showColumn(param.fieldid)
if apply_sorting:
if param.sortorder in [
Qt.AscendingOrder, Qt.DescendingOrder
]:
self.horizontalHeader().setSortIndicator(
param.fieldid, param.sortorder)
self.sortByColumn(param.fieldid, Qt.AscendingOrder)
for param in self.listParam.columns:
if param.width:
self.horizontalHeader().resizeSection(param.fieldid,
param.width)
self.horizontalHeader().sectionResized.connect(self.columnResized)
self._updateHeaderButtons()
def viewInBrowser(self, template=None):
if not template:
template = Settings()['template']
template_name = os.path.basename(template)
dstPath = os.path.join(TemporaryDir.path(), template_name + '.htm')
report = Report(self.model(), template, dstPath, self)
indexes = self.selectedRows()
if indexes:
fileName = report.generate(indexes)
if fileName:
executor = QDesktopServices()
executor.openUrl(QtCore.QUrl.fromLocalFile(fileName))
else:
QMessageBox.information(
self, self.tr("Report preview"),
self.tr("Nothing selected.\nSelect required coins by clicking "
"with Ctrl or Shift, or Ctrl+A for select all coins."))
def setCollection(self, collection):
self.collection.loadReference(Settings()['reference'])
self.__setEnabledActs(True)
self.collectionFileLabel.setText(collection.getFileName())
title = "%s - %s" % (collection.getCollectionName(), version.AppName)
self.setWindowTitle(title)
latest = LatestCollections(self)
latest.add(collection.getFileName())
self.__updateLatest()
self.viewTab.setCollection(collection)
self.referenceMenu.clear()
for action in self.collection.referenceMenu(self):
self.referenceMenu.addAction(action)
def backup(self):
backupDir = QtCore.QDir(Settings()['backup'])
if not backupDir.exists():
backupDir.mkpath(backupDir.path())
backupFileName = backupDir.filePath(
"%s_%s.db" %
(self.getCollectionName(),
QtCore.QDateTime.currentDateTime().toString('yyMMddhhmm')))
srcFile = QtCore.QFile(self.fileName)
if not srcFile.copy(backupFileName):
QMessageBox.critical(
self.parent(), self.tr("Backup collection"),
self.tr("Can't make a collection backup at %s") %
backupFileName)
return False
return True
def __init__(self, treeParam, parent=None):
super(TreeView, self).__init__(parent)
self.settings = Settings()
self.setHeaderHidden(True)
self.setAutoScroll(False)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.contextMenuEvent)
self.currentItemChanged.connect(self.itemActivatedEvent)
self.itemExpanded.connect(self.expandedEvent)
self.collapsed.connect(self.collapsedEvent)
self.treeParam = treeParam
# Changing of TreeView is enabled (by signals from model or ListView)
self.changingEnabled = True
def setModel(self, model):
self.model = model
self.imageFields = []
for field in self.model.fields.userFields:
if field.type in (Type.Image, Type.EdgeImage):
self.imageFields.append(field)
# By default show only first 2 images
self.showedCount = Settings()['images_by_default']
self.imageButtons = []
for field in self.imageFields:
button = QCheckBox(self)
button.setToolTip(field.title)
button.setDisabled(True)
button.stateChanged.connect(self.buttonClicked)
self.imageButtons.append(button)
self.buttonLayout.addWidget(button)
def __init__(self, listParam, parent=None):
super(ListView, self).__init__(parent)
self.listParam = listParam
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.doubleClicked.connect(self.itemDClicked)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.contextMenuEvent)
self.setSortingEnabled(True)
self.horizontalHeader().setSectionsMovable(True)
self.horizontalHeader().sectionDoubleClicked.connect(
self.sectionDoubleClicked)
self.horizontalHeader().sectionResized.connect(self.columnResized)
self.horizontalHeader().sectionMoved.connect(self.columnMoved)
self.horizontalHeader().setContextMenuPolicy(Qt.CustomContextMenu)
self.horizontalHeader().customContextMenuRequested.connect(
self.headerContextMenuEvent)
if Settings()['store_sorting']:
self.horizontalHeader().sortIndicatorChanged.connect(
self.sortChangedEvent)
self.horizontalScrollBar().valueChanged.connect(self.scrolled)
self.horizontalHeader().setDefaultAlignment(Qt.AlignLeft)
# Make header font always bold
font = self.horizontalHeader().font()
font.setBold(True)
self.horizontalHeader().setFont(font)
self.verticalHeader().setVisible(False)
self.defaultHeight = self.verticalHeader().defaultSectionSize()
self.listCountLabel = QLabel()
self.listSelectedLabel = QLabel(self.tr("0 coin(s) selected"))
# Show image data as images
for field in listParam.fields:
if field.type in Type.ImageTypes:
self.setItemDelegateForColumn(field.id, ImageDelegate(self))
self.selectedRowId = None
def mapLayout(self):
self.map_item = None
coordinates_enabled = not (self.items['latitude'].isHidden() or
self.items['longitude'].isHidden())
if importedQtWebKit and coordinates_enabled:
settings = Settings()
if settings['map_type'] == 0 or not gmapsAvailable:
self.map_item = OSMWidget(self)
else:
self.map_item = GMapsWidget(self)
self.map_item.markerMoved.connect(self.mapMarkerMoved)
self.map_item.markerRemoved.connect(self.mapMarkerRemoved)
self.items['address'].widget().findClicked.connect(self.map_item.geocode)
self.items['latitude'].widget().textChanged.connect(self.mapChanged)
self.items['longitude'].widget().textChanged.connect(self.mapChanged)
return self.map_item
def __init__(self, columnParam, listParam, model, parent):
super(FilterMenuButton, self).__init__(parent)
self.db = model.database()
self.model = model
self.columnName = self.model.fields.fields[columnParam.fieldid].name
self.fieldid = columnParam.fieldid
self.filters = listParam.filters
self.listParam = listParam
self.settings = Settings()
menu = QMenu()
self.setToolTip(self.tr("Filter items"))
self.setFixedHeight(self.parent().height() - 2)
self.setFixedWidth(self.height())
self.setMenu(menu)
if self.fieldid in self.filters.keys():
self.setIcon(createIcon('filters.ico'))
menu.aboutToShow.connect(self.prepareMenu)
def __init__(self, parent=None):
super().__init__(parent)
self.settings = Settings()
