def create_central_widget(self):
widget = QWidget()
vbox = QHBoxLayout()
# widget.setLayout(grid)
my_dir_list = QListWidget()
my_dir_list.itemClicked.connect(self.select_dir)
my_dir_list.addItem(os.path.join(os.environ['HOME'], '.icons'))
my_dir_list.addItems([os.path.join(x, 'icons') for x in get_xdr_data_dirs()])
my_dir_list.addItem('/usr/share/pixmaps')
vbox.addWidget(my_dir_list)
self.theme_list = QListWidget()
self.theme_list.itemClicked.connect(self.select_theme)
vbox.addWidget(self.theme_list)
self.sub_dir_list = QListWidget()
self.sub_dir_list.itemClicked.connect(self.select_sub_dir)
vbox.addWidget(self.sub_dir_list)
self.icon_list = QListWidget()
self.icon_list.itemClicked.connect(self.select_icon)
vbox.addWidget(self.icon_list)
self.image = QLabel()
self.image.setFixedWidth(150)
vbox.addWidget(self.image)
widget.setLayout(vbox)
return widget
def create_central_widget(self):
widget = QWidget()
vbox = QHBoxLayout()
# widget.setLayout(grid)
my_dir_list = QListWidget()
my_dir_list.itemClicked.connect(self.select_dir)
my_dir_list.addItem(os.path.join(os.environ['HOME'], '.icons'))
my_dir_list.addItems(
[os.path.join(x, 'icons') for x in get_xdr_data_dirs()])
my_dir_list.addItem('/usr/share/pixmaps')
vbox.addWidget(my_dir_list)
self.theme_list = QListWidget()
self.theme_list.itemClicked.connect(self.select_theme)
vbox.addWidget(self.theme_list)
self.sub_dir_list = QListWidget()
self.sub_dir_list.itemClicked.connect(self.select_sub_dir)
vbox.addWidget(self.sub_dir_list)
self.icon_list = QListWidget()
self.icon_list.itemClicked.connect(self.select_icon)
vbox.addWidget(self.icon_list)
self.image = QLabel()
self.image.setFixedWidth(150)
vbox.addWidget(self.image)
widget.setLayout(vbox)
return widget
class OpenProjectType(QDialog, ProjectWizard):
def __init__(self, main):
QDialog.__init__(self)
ProjectWizard.__init__(self)
self._main = main
self.setModal(True)
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel('Select the Type of Project:'))
self.listWidget = QListWidget()
projectTypes = self.types.keys()
projectTypes.sort()
self.listWidget.addItems(projectTypes)
vbox.addWidget(self.listWidget)
btnNext = QPushButton('Next')
vbox.addWidget(btnNext)
if len(projectTypes) > 0:
self.listWidget.setCurrentRow(0)
else:
btnNext.setEnabled(False)
self.connect(btnNext, SIGNAL("clicked()"), self._open_project)
def _open_project(self):
type_ = str(self.listWidget.currentItem().text())
extensions = self.types[type_].projectFiles()
if extensions is None:
self._main.open_project_folder()
else:
self._main.open_project_type(extensions)
class OpenProjectType(QDialog, ProjectWizard):
def __init__(self, main):
QDialog.__init__(self)
ProjectWizard.__init__(self)
self._main = main
self.setModal(True)
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel('Select the Type of Project:'))
self.listWidget = QListWidget()
projectTypes = self.types.keys()
projectTypes.sort()
self.listWidget.addItems(projectTypes)
vbox.addWidget(self.listWidget)
btnNext = QPushButton('Next')
vbox.addWidget(btnNext)
if len(projectTypes) > 0:
self.listWidget.setCurrentRow(0)
else:
btnNext.setEnabled(False)
self.connect(btnNext, SIGNAL("clicked()"), self._open_project)
def _open_project(self):
type_ = str(self.listWidget.currentItem().text())
extensions = self.types[type_].projectFiles()
if extensions is None:
self._main.open_project_folder()
else:
self._main.open_project_type(extensions)
class PageProjectType(QWizardPage):
def __init__(self, wizard):
QWizardPage.__init__(self)
self.setTitle(self.tr("Project Type"))
self.setSubTitle(self.tr("Choose the Project Type"))
self._wizard = wizard
vbox = QVBoxLayout(self)
self.listWidget = QListWidget()
vbox.addWidget(self.listWidget)
types = settings.get_all_project_types()
types.sort()
index = types.index('Python')
types.insert(0, types.pop(index))
self.listWidget.addItems(types)
self.listWidget.setCurrentRow(0)
self.connect(self.listWidget,
SIGNAL("itemClicked(QListWidgetItem *)"),
self.load_pages)
def validatePage(self):
self._wizard.option = self.listWidget.currentItem().text()
return True
def load_pages(self):
self.wizard().add_project_pages(self.listWidget.currentItem().text())
class SelectFromListDialog(QDialog):
def __init__(self, options, parent=None, title=''):
super(SelectFromListDialog, self).__init__(parent)
layout = QVBoxLayout(self)
self.setWindowTitle(title)
self.setStyleSheet("background-color: rgb(245,247,255);")
# nice widget for editing the date
self.selector = QListWidget(self)
self.selector.addItems(list(options))
layout.addWidget(self.selector)
# OK and Cancel buttons
self.buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
layout.addWidget(self.buttons)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
def selected(self):
items = self.selector.selectedItems()
q_text = items[0].text()
return str(q_text)
@staticmethod
def get_selected(options, parent=None, title=''):
dialog = SelectFromListDialog(options, parent, title)
dialog.selector.setItemSelected(dialog.selector.item(0), True)
result = dialog.exec_()
focus = dialog.selected()
return focus, result == QDialog.Accepted
class CardListWidged(QWidget):
def __init__(self):
super(CardListWidged, self).__init__()
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.word_list = QListWidget(self)
self.word_list.currentItemChanged.connect(self.on_item_changed)
self.layout.addWidget(self.word_list)
#making control panel
self.control_panel = ControlPanel(self)
self.layout.addWidget(self.control_panel)
#create word edit widget
self.card_edit_widget = CardEditWidget(self)
self.layout.addWidget(self.card_edit_widget)
self.cards = []
self.cards = load_cards()
self._update_word_list()
def _update_word_list(self):
self.word_list.clear()
words = []
for card in self.cards:
words.append(card.word)
self.word_list.addItems(words)
def on_item_changed(self, curr, prev):
word = curr.text()
card = find_card_by_word(self.cards, word)
self.card_edit_widget.show_card(card)
class SelectFromListDialog(QDialog):
def __init__(self, options, parent=None, title=''):
super(SelectFromListDialog, self).__init__(parent)
layout = QVBoxLayout(self)
self.setWindowTitle(title)
self.setStyleSheet("background-color: rgb(245,247,255);")
# nice widget for editing the date
self.selector = QListWidget(self)
self.selector.addItems(list(options))
layout.addWidget(self.selector)
# OK and Cancel buttons
self.buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Horizontal, self)
layout.addWidget(self.buttons)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
def selected(self):
items = self.selector.selectedItems()
q_text = items[0].text()
return str(q_text)
@staticmethod
def get_selected(options, parent=None, title=''):
dialog = SelectFromListDialog(options, parent, title)
dialog.selector.setItemSelected(dialog.selector.item(0), True)
result = dialog.exec_()
focus = dialog.selected()
return focus, result == QDialog.Accepted
class ProfilesLoader(QDialog):
def __init__(self, load_func, profiles, parent=None):
QDialog.__init__(self, parent, Qt.Dialog)
self.setMinimumWidth(400)
self._profiles = profiles
self.load_function = load_func
vbox = QVBoxLayout(self)
self.profileList = QListWidget()
self.profileList.addItems([key for key in profiles])
self.contentList = QListWidget()
self.contentList.setSortingEnabled(True)
self.btnDelete = QPushButton(self.tr("Delete Profile"))
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(self.tr("Open Profile"))
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.profileList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.profileList, SIGNAL("itemSelectionChanged()"),
self.load_profile_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_profile)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_profile)
def load_profile_content(self):
item = self.profileList.currentItem()
self.contentList.clear()
key = unicode(item.text())
content = self._profiles[key]
self.contentList.addItems(content)
def open_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self.load_function(key)
self.close()
def delete_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self._profiles.pop(key)
self.profileList.takeItem(self.profileList.currentRow())
self.contentList.clear()
class PageProjectType(QWizardPage):
def __init__(self, wizard):
QWizardPage.__init__(self)
self.setTitle(self.tr("Project Type"))
self.setSubTitle(self.tr("Choose the Project Type"))
self._wizard = wizard
vbox = QVBoxLayout(self)
self.listWidget = QListWidget()
vbox.addWidget(self.listWidget)
types = settings.get_all_project_types()
types.sort()
index = types.index('Python')
types.insert(0, types.pop(index))
self.listWidget.addItems(types)
self.listWidget.setCurrentRow(0)
class PageProjectType(QWizardPage):
def __init__(self, wizard):
QWizardPage.__init__(self)
self.setTitle(self.tr("Project Type"))
self.setSubTitle(self.tr("Choose the Project Type"))
self._wizard = wizard
vbox = QVBoxLayout(self)
self.listWidget = QListWidget()
vbox.addWidget(self.listWidget)
types = settings.get_all_project_types()
types.sort()
index = types.index('Python')
types.insert(0, types.pop(index))
self.listWidget.addItems(types)
self.listWidget.setCurrentRow(0)
class PanelPage(QWizardPage):
def __init__(self):
super(PanelPage, self).__init__()
self.setTitle('生成信息')
self.setSubTitle('显示工程配置的简要信息和即将生成的文件')
def initializePage(self):
super(PanelPage, self).initializePage()
rootLayout = QVBoxLayout()
rootLayout.setContentsMargins(20, 20, 10, 20)
row0 = QHBoxLayout()
lable0 = QLabel('依赖库:')
lable0.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
self.lw_files = QListWidget()
items0 = QStringList()
for moudel in app.g_configurations.libs:
items0.append(moudel['name'])
self.lw_files.addItems(items0)
row0.addWidget(lable0)
row0.addSpacing(25)
row0.addWidget(self.lw_files)
row1 = QHBoxLayout()
lable1 = QLabel('工程文件:')
lable1.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
self.lw_files = QListWidget()
self.lw_files.setStyleSheet("Height:66px;")
items1 = QStringList()
for file in app.g_configurations.config['files']:
items1.append(file['target'])
self.lw_files.addItems(items1)
row1.addWidget(lable1)
row1.addSpacing(10)
row1.addWidget(self.lw_files)
rootLayout.addLayout(row0)
rootLayout.addSpacing(10)
rootLayout.addLayout(row1)
self.setLayout(rootLayout)
self.setStyleSheet(stylesheet)
def validatePage(self):
return True
class PageProjectType(QWizardPage):
def __init__(self, wizard):
QWizardPage.__init__(self)
self.setTitle("Project Type")
self.setSubTitle("Choose the Project Type")
self._wizard = wizard
vbox = QVBoxLayout(self)
self.listWidget = QListWidget()
vbox.addWidget(self.listWidget)
types = self._wizard.types.keys()
types.sort()
self.listWidget.addItems(types)
index = types.index("Python")
self.listWidget.setCurrentRow(index)
self.connect(self.listWidget, SIGNAL("itemSelectionChanged()"), self.item_changed)
def item_changed(self):
self._wizard.add_project_pages(str(self.listWidget.currentItem().text()))
class PageProjectType(QWizardPage):
def __init__(self, wizard):
QWizardPage.__init__(self)
self.setTitle('Project Type')
self.setSubTitle('Choose the Project Type')
self._wizard = wizard
vbox = QVBoxLayout(self)
self.listWidget = QListWidget()
vbox.addWidget(self.listWidget)
types = self._wizard.types.keys()
types.sort()
self.listWidget.addItems(types)
index = types.index('Python')
self.listWidget.setCurrentRow(index)
self.connect(self.listWidget, SIGNAL("itemSelectionChanged()"), self.item_changed)
def item_changed(self):
self._wizard.add_project_pages(str(self.listWidget.currentItem().text()))
class PanelPage(QWizardPage):
def __init__(self):
super(PanelPage,self).__init__()
self.setTitle('生成信息')
self.setSubTitle('显示工程配置的简要信息和即将生成的文件')
def initializePage(self):
super(PanelPage, self).initializePage()
rootLayout = QVBoxLayout()
rootLayout.setContentsMargins(20, 30, 20, 30)
row0 = QHBoxLayout()
lable0 = QLabel(' 依赖库：')
lable0.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
self.lw_files = QListWidget()
items0 = QStringList()
for moudel in app.g_configurations.libs:
items0.append(moudel['name'])
self.lw_files.addItems(items0)
row0.addWidget(lable0)
row0.addWidget(self.lw_files)
row1 = QHBoxLayout()
lable1 = QLabel('工程文件：')
lable1.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
self.lw_files = QListWidget()
items1 = QStringList()
for file in app.g_configurations.config['files']:
items1.append(file['target'])
self.lw_files.addItems(items1)
row1.addWidget(lable1)
row1.addWidget(self.lw_files)
rootLayout.addLayout(row0)
rootLayout.addLayout(row1)
self.setLayout(rootLayout)
def validatePage(self):
return True
class DelCategoriesDlg(QDialog):
def __init__(self, categories, parent=None):
super(DelCategoriesDlg, self).__init__(parent)
self.setWindowTitle('Address Book - Delete Categories')
self.resize(302, 307)
self.parent = parent
self.db = self.parent.db
self.categories = categories
self.ListWidget = QListWidget()
self.delButton = QPushButton('Delete')
vlayout = pyqttools.add_to_layout(QVBoxLayout(),(self.delButton, None))
f_layout = pyqttools.add_to_layout(QHBoxLayout(),
(self.ListWidget, vlayout))
self.setLayout(f_layout)
self.delButton.clicked.connect(self.delete)
self.fill_ListWidget()
def fill_ListWidget(self):
self.ListWidget.clear()
self.ListWidget.addItems(self.categories)
self.set_enable()
def set_enable(self):
self.delButton.setEnabled(bool(self.ListWidget))
def delete(self):
categ = self.ListWidget.currentItem().text()
categ_id = self.db.get_category_id(categ, self.parent.user)
reply = QMessageBox.question(self, 'Address Book - Delete User',
'Are sou sure that you want to delete {0} and all its contacts?'\
.format(categ), QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
self.db.delete_category(categ_id)
self.categories.remove(categ)
self.fill_ListWidget()
def add_slice(self, param=[]):
"""Add a row to the slice table and append it to the
daqCollection instance for analysis.
param -- [name, start (ms), end (ms), channels]"""
try:
name, start, end, channels = param
except TypeError:
name = 'Slice' + str(self.slices.rowCount())
start = 0
end = self.stats['Duration (ms)']
channels = list(self.stats['channels'].keys())
i = self.slices.rowCount() # index to add row at
self.slices.insertRow(i) # add row to table
validator = QDoubleValidator(0., float(self.stats['Duration (ms)']), 3)
for j, text in enumerate([name, str(start), str(end)]):
item = QLineEdit(text)
item.pos = (i, j)
if j > 0:
item.setValidator(validator)
item.textChanged.connect(self.update_slices)
self.slices.setCellWidget(i, j, item)
chanbox = QListWidget(self)
chanbox.setSelectionMode(
3) # extended selection, allows multiple selection
chanbox.itemSelectionChanged.connect(self.update_slices)
chanbox.pos = (i, 3)
chanbox.text = chanbox.objectName
chanlist = list(self.stats['channels'].keys())
chanbox.addItems(chanlist)
self.slices.setCellWidget(i, j + 1, chanbox)
self.slices.resizeRowToContents(i)
# add to the dc list of slices
t = np.linspace(0, self.stats['Duration (ms)'] / 1000, self.n_samples)
self.dc.add_slice(
name, np.argmin(np.abs(t - start)), np.argmin(np.abs(t - end)),
OrderedDict([(chan, chanlist.index(chan)) for chan in channels]))
self.reset_lines()
def hyphenate(text, mainwindow):
"""
Ask the user which language to use.
Returns None if the user cancels the dialog or no hyphenation pattern files
could be found.
"""
if not hyphdicts:
KMessageBox.sorry(mainwindow, i18n(
"Could not find any hyphenation dictionaries.\n\n"
"Please install a package containing some and/or or configure the "
"search path to find them in the Frescobaldi settings under "
"\"Paths.\""))
return
conf = config("hyphenation")
lang = conf.readEntry("lastused", "")
langs = list(sorted(hyphdicts.keys()))
index = lang in langs and langs.index(lang) or 0
d = KDialog(mainwindow)
d.setButtons(KDialog.ButtonCode(KDialog.Ok | KDialog.Cancel | KDialog.Help))
d.setCaption(i18n("Hyphenate Lyrics Text"))
d.setHelp("lyrics")
layout = QVBoxLayout()
d.mainWidget().setLayout(layout)
layout.addWidget(QLabel(i18n("Please select a language:")))
listbox = QListWidget()
layout.addWidget(listbox)
listbox.addItems(langs)
listbox.setCurrentRow(index)
listbox.setFocus()
if d.exec_():
lang = langs[listbox.currentRow()]
conf.writeEntry("lastused", lang)
conf.sync()
# get hyphenator
h = Hyphenator(hyphdicts[lang])
return ly.rx.lyric_word.sub(lambda m: h.inserted(m.group(), ' -- '), text)
class StringListDlg(QDialog):
acceptedList = Signal(QStringList)
def __init__(self, name, stringlist=None, parent=None):
super(StringListDlg, self).__init__(parent)
self.name = name
self.create_widgets(stringlist)
self.layout_widgets()
self.setWindowTitle("Edit {0} List".format(self.name))
def create_widgets(self, stringlist):
self.listWidget = QListWidget()
if stringlist is not None:
self.listWidget.addItems(stringlist)
self.listWidget.setCurrentRow(0)
def layout_widgets(self):
buttonLayout = QVBoxLayout()
for text, slot in (("&Add...", self.add),
("&Edit...", self.edit),
("&Remove...", self.remove),
("&Up", self.up),
("&Down", self.down),
("&Sort", self.listWidget.sortItems),
("Close", self.accept)):
button = QPushButton(text)
if not MAC:
button.setFocusPolicy(Qt.NoFocus)
if text == "Close":
buttonLayout.addStretch()
buttonLayout.addWidget(button)
button.clicked.connect(slot)
layout = QHBoxLayout()
layout.addWidget(self.listWidget)
layout.addLayout(buttonLayout)
self.setLayout(layout)
def add(self):
row = self.listWidget.currentRow()
title = "Add {0}".format(self.name)
string, ok = QInputDialog.getText(self, title, title)
if ok and not string.isEmpty():
self.listWidget.insertItem(row, string)
def edit(self):
row = self.listWidget.currentRow()
item = self.listWidget.item(row)
if item is not None:
title = "Edit {0}".format(self.name)
string, ok = QInputDialog.getText(self, title, title,
QLineEdit.Normal, item.text())
if ok and not string.isEmpty():
item.setText(string)
def remove(self):
row = self.listWidget.currentRow()
item = self.listWidget.item(row)
if item is None:
return
reply = QMessageBox.question(self, "Remove {0}".format(
self.name), "Remove {0} `{1}'?".format(
self.name, unicode(item.text())),
QMessageBox.Yes|QMessageBox.No)
if reply == QMessageBox.Yes:
item = self.listWidget.takeItem(row)
del item
def up(self):
row = self.listWidget.currentRow()
if row >= 1:
item = self.listWidget.takeItem(row)
self.listWidget.insertItem(row - 1, item)
self.listWidget.setCurrentItem(item)
def down(self):
row = self.listWidget.currentRow()
if row < self.listWidget.count() - 1:
item = self.listWidget.takeItem(row)
self.listWidget.insertItem(row + 1, item)
self.listWidget.setCurrentItem(item)
def reject(self):
self.accept()
def accept(self):
self.stringlist = QStringList()
for row in range(self.listWidget.count()):
self.stringlist.append(self.listWidget.item(row).text())
self.acceptedList.emit(self.stringlist)
QDialog.accept(self)
class ChainComposerDialog(QDialog):
def __init__(self, parent=None):
super(ChainComposerDialog, self).__init__(parent)
self.setWindowTitle("Composer Chain")
layout = QVBoxLayout()
mainLayout = QHBoxLayout()
selectionLayout = QVBoxLayout()
label = QLabel("Available Filters:")
selectionLayout.addWidget(label)
self.__selectionList = QListWidget()
selectionLayout.addWidget(self.__selectionList)
mainLayout.addLayout(selectionLayout)
actionsLayout = QVBoxLayout()
actionsLayout.addStretch()
addButton = QPushButton("Add>>")
addButton.clicked.connect(self.__handleAdd)
actionsLayout.addWidget(addButton)
removeButton = QPushButton("Remove")
actionsLayout.addWidget(removeButton)
removeAllButton = QPushButton("Remove All")
actionsLayout.addWidget(removeAllButton)
actionsLayout.addStretch()
mainLayout.addLayout(actionsLayout)
chainLayout = QVBoxLayout()
chainLayout.addWidget(QLabel("Chain:"))
self.__chainList = QListWidget()
chainLayout.addWidget(self.__chainList)
mainLayout.addLayout(chainLayout)
layout.addLayout(mainLayout)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.okClick)
buttonBox.rejected.connect(self.cancelClick)
layout.addWidget(buttonBox)
# buttonLayout = QHBoxLayout()
# okButton = QPushButton('OK')
# okButton.clicked.connect(self.accept)
# buttonLayout.addWidget(okButton)
# cancelButton = QPushButton('Cancel')
# cancelButton.clicked.connect(self.reject)
# buttonLayout.addWidget(cancelButton)
# layout.addLayout(buttonLayout)
self.setLayout(layout)
self.__composer = None
def okClick(self):
print "OK!"
self.accept()
def cancelClick(self):
print "Cancel"
self.reject()
def setComposer(self, composer):
self.__composer = composer
@property
def selectionList(self):
return self.__getStrings(self.__selectionList)
@selectionList.setter
def setSelectionList(self, filters):
for i in xrange(self.__selectionList.count()):
self.__selectionList.takeItem(i)
self.__selectionList.addItems(filters)
def filterAt(self, row):
return self.__selectionList.item(row).text()
def addToChain(self, filterName):
self.__chainList.addItem(filterName)
@property
def composedFilter(self):
return self.__getStrings(self.__chainList)
@staticmethod
def __getStrings(listWidget):
return tuple(listWidget.item(i) for i in range(listWidget.count()))
def __handleAdd(self):
if self.__composer is None:
return
for item in self.__selectionList.selectedItems():
row = self.__selectionList.row(item)
self.__composer.add(row)
class ProfilesLoader(QDialog):
def __init__(self, load_func, create_func, save_func,
profiles, parent=None):
QDialog.__init__(self, parent, Qt.Dialog)
self.setMinimumWidth(400)
self._profiles = profiles
self.load_function = load_func
self.create_function = create_func
self.save_function = save_func
self.ide = parent
vbox = QVBoxLayout(self)
self.profileList = QListWidget()
self.profileList.addItems([key for key in profiles])
self.profileList.setCurrentRow(0)
self.contentList = QListWidget()
self.btnDelete = QPushButton(self.tr("Delete Profile"))
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnUpdate = QPushButton(self.tr("Update Profile"))
self.btnUpdate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnCreate = QPushButton(self.tr("Create New Profile"))
self.btnCreate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(self.tr("Open Profile"))
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnUpdate)
hbox.addWidget(self.btnCreate)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.profileList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.profileList, SIGNAL("itemSelectionChanged()"),
self.load_profile_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_profile)
self.connect(self.btnUpdate, SIGNAL("clicked()"), self.save_profile)
self.connect(self.btnCreate, SIGNAL("clicked()"), self.create_profile)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_profile)
def load_profile_content(self):
item = self.profileList.currentItem()
self.contentList.clear()
if item is not None:
key = unicode(item.text())
files = [self.tr('Files:')] + \
[file[0] for file in self._profiles[key][0]]
projects = [self.tr('Projects:')] + self._profiles[key][1]
content = files + projects
self.contentList.addItems(content)
def create_profile(self):
profileName = self.create_function()
self.ide.Profile = profileName
self.close()
def save_profile(self):
if self.profileList.currentItem():
profileName = unicode(self.profileList.currentItem().text())
self.save_function(profileName)
self.ide.show_status_message(self.tr("Profile %1 Updated!").arg(
profileName))
self.load_profile_content()
def open_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self.load_function(key)
self.ide.Profile = key
self.close()
def delete_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self._profiles.pop(key)
self.profileList.takeItem(self.profileList.currentRow())
self.contentList.clear()
class ListEdit(QWidget):
"""A widget to edit a list of items (e.g. a list of directories)."""
# emitted when anything changed in the listbox.
changed = pyqtSignal()
def __init__(self, *args, **kwargs):
QWidget.__init__(self, *args, **kwargs)
layout = QGridLayout(self)
self.setLayout(layout)
self.addButton = QPushButton(icons.get('list-add'), '')
self.editButton = QPushButton(icons.get('document-edit'), '')
self.removeButton = QPushButton(icons.get('list-remove'), '')
self.listBox = QListWidget()
layout.setContentsMargins(1, 1, 1, 1)
layout.setSpacing(0)
layout.addWidget(self.listBox, 0, 0, 8, 1)
layout.addWidget(self.addButton, 0, 1)
layout.addWidget(self.editButton, 1, 1)
layout.addWidget(self.removeButton, 2, 1)
@self.addButton.clicked.connect
def addClicked():
item = self.createItem()
if self.openEditor(item):
self.addItem(item)
@self.editButton.clicked.connect
def editClicked():
item = self.listBox.currentItem()
item and self.editItem(item)
@self.removeButton.clicked.connect
def removeClicked():
item = self.listBox.currentItem()
if item:
self.removeItem(item)
@self.listBox.itemDoubleClicked.connect
def itemDoubleClicked(item):
item and self.editItem(item)
self.listBox.model().layoutChanged.connect(self.changed)
def updateSelection():
selected = bool(self.listBox.currentItem())
self.editButton.setEnabled(selected)
self.removeButton.setEnabled(selected)
self.changed.connect(updateSelection)
self.listBox.itemSelectionChanged.connect(updateSelection)
updateSelection()
app.translateUI(self)
def translateUI(self):
self.addButton.setText(_("&Add..."))
self.editButton.setText(_("&Edit..."))
self.removeButton.setText(_("&Remove"))
def createItem(self):
return QListWidgetItem()
def addItem(self, item):
self.listBox.addItem(item)
self.itemChanged(item)
self.changed.emit()
def removeItem(self, item):
self.listBox.takeItem(self.listBox.row(item))
self.changed.emit()
def editItem(self, item):
if self.openEditor(item):
self.itemChanged(item)
self.changed.emit()
def setCurrentItem(self, item):
self.listBox.setCurrentItem(item)
def setCurrentRow(self, row):
self.listBox.setCurrentRow(row)
def openEditor(self, item):
"""Opens an editor (dialog) for the item.
Returns True if the dialog was accepted and the item edited.
Returns False if the dialog was cancelled (the item must be left
unedited).
"""
pass
def itemChanged(self, item):
"""Called after an item has been added or edited.
Re-implement to do something at this moment if needed, e.g. alter the
text or display of other items.
"""
pass
def setValue(self, strings):
"""Sets the listbox to a list of strings."""
self.listBox.clear()
self.listBox.addItems(strings)
self.changed.emit()
def value(self):
"""Returns the list of paths in the listbox."""
return [self.listBox.item(i).text()
for i in range(self.listBox.count())]
def setItems(self, items):
"""Sets the listbox to a list of items."""
self.listBox.clear()
for item in items:
self.listBox.addItem(item)
self.itemChanged(item)
self.changed.emit()
def items(self):
"""Returns the list of items in the listbox."""
return [self.listBox.item(i)
for i in range(self.listBox.count())]
def clear(self):
"""Clears the listbox."""
self.listBox.clear()
self.changed.emit()
class GroupsModify(QDialog):
"""
+--------------------------+
| Groups : Modify |
+--------------------------+
| |
| Name xxx Default |
| Coords xxx Default |
| Elements xxx Default |
| Color xxx Default |
| Add xxx Add |
| Remove xxx Remove |
| |
| Set OK Cancel |
+--------------------------+
"""
def __init__(self, data, win_parent=None, group_active='main'):
self.win_parent = win_parent
QDialog.__init__(self, win_parent)
self.win_parent = win_parent
self.out_data = data
#print(data)
self.keys = [group.name for key, group in sorted(iteritems(data))]
self.active_key = self.keys.index(group_active)
group_obj = data[self.active_key]
name = group_obj.name
self.imain = 0
self.nrows = len(self.keys)
self._default_name = group_obj.name
self._default_elements = group_obj.element_str
self.elements_pound = group_obj.elements_pound
self.table = QListWidget(parent=None)
self.table.clear()
self.table.addItems(self.keys)
# table
self.setWindowTitle('Groups: Modify')
self.create_widgets()
self.create_layout()
self.set_connections()
self.on_set_as_main()
#self.show()
def create_widgets(self):
# Name
self.name = QLabel("Name:")
self.name_set = QPushButton("Set")
self.name_edit = QLineEdit(str(self._default_name).strip())
self.name_button = QPushButton("Default")
# elements
self.elements = QLabel("Element IDs:")
self.elements_edit = QLineEdit(str(self._default_elements).strip())
self.elements_button = QPushButton("Default")
# add
self.add = QLabel("Add:")
self.add_edit = QLineEdit(str(''))
self.add_button = QPushButton("Add")
# remove
self.remove = QLabel("Remove:")
self.remove_edit = QLineEdit(str(''))
self.remove_button = QPushButton("Remove")
# applies a unique implicitly
self.eids = parse_patran_syntax(str(self._default_elements), pound=self.elements_pound)
# closing
#self.apply_button = QPushButton("Apply")
self.ok_button = QPushButton("Close")
#self.cancel_button = QPushButton("Cancel")
self.set_as_main_button = QPushButton("Set As Main")
self.create_group_button = QPushButton('Create New Group')
self.delete_group_button = QPushButton('Delete Group')
self.name.setEnabled(False)
self.name_set.setEnabled(False)
self.name_edit.setEnabled(False)
self.name_button.setEnabled(False)
self.elements.setEnabled(False)
self.elements_button.setEnabled(False)
self.elements_edit.setEnabled(False)
self.add.setEnabled(False)
self.add_button.setEnabled(False)
self.add_edit.setEnabled(False)
self.remove.setEnabled(False)
self.remove_button.setEnabled(False)
self.remove_edit.setEnabled(False)
self.delete_group_button.setEnabled(False)
#self.apply_button.setEnabled(False)
#self.ok_button.setEnabled(False)
def create_layout(self):
grid = QGridLayout()
grid.addWidget(self.name, 0, 0)
grid.addWidget(self.name_edit, 0, 1)
grid.addWidget(self.name_set, 0, 2)
grid.addWidget(self.name_button, 0, 3)
grid.addWidget(self.elements, 2, 0)
grid.addWidget(self.elements_edit, 2, 1)
grid.addWidget(self.elements_button, 2, 2)
grid.addWidget(self.add, 4, 0)
grid.addWidget(self.add_edit, 4, 1)
grid.addWidget(self.add_button, 4, 2)
grid.addWidget(self.remove, 5, 0)
grid.addWidget(self.remove_edit, 5, 1)
grid.addWidget(self.remove_button, 5, 2)
ok_cancel_box = QHBoxLayout()
#ok_cancel_box.addWidget(self.apply_button)
ok_cancel_box.addWidget(self.ok_button)
#ok_cancel_box.addWidget(self.cancel_button)
main_create_delete = QHBoxLayout()
main_create_delete.addWidget(self.set_as_main_button)
main_create_delete.addWidget(self.create_group_button)
main_create_delete.addWidget(self.delete_group_button)
vbox = QVBoxLayout()
vbox.addWidget(self.table)
vbox.addLayout(grid)
vbox.addLayout(main_create_delete)
vbox.addStretch()
vbox.addLayout(ok_cancel_box)
self.setLayout(vbox)
def on_set_name(self):
name = str(self.name_edit.text()).strip()
if name not in self.keys:
self.name_edit.setStyleSheet("QLineEdit{background: white;}")
group = self.out_data[self.active_key]
group.name = name
self.keys[self.active_key] = name
self.recreate_table()
elif name != self.keys[self.active_key]:
self.name_edit.setStyleSheet("QLineEdit{background: red;}")
elif name == self.keys[self.active_key]:
self.name_edit.setStyleSheet("QLineEdit{background: white;}")
def set_connections(self):
if qt_version == 4:
self.connect(self.name_set, QtCore.SIGNAL('clicked()'), self.on_set_name)
self.connect(self.name_button, QtCore.SIGNAL('clicked()'), self.on_default_name)
self.connect(self.elements_button, QtCore.SIGNAL('clicked()'), self.on_default_elements)
self.connect(self.add_button, QtCore.SIGNAL('clicked()'), self.on_add)
self.connect(self.remove_button, QtCore.SIGNAL('clicked()'), self.on_remove)
self.connect(self.table, QtCore.SIGNAL('itemClicked(QListWidgetItem *)'), self.on_update_active_key)
#self.connect(self.apply_button, QtCore.SIGNAL('clicked()'), self.on_apply)
self.connect(self.ok_button, QtCore.SIGNAL('clicked()'), self.on_ok)
#self.connect(self.cancel_button, QtCore.SIGNAL('clicked()'), self.on_cancel)
self.connect(self.set_as_main_button, QtCore.SIGNAL('clicked()'), self.on_set_as_main)
self.connect(self.create_group_button, QtCore.SIGNAL('clicked()'), self.on_create_group)
self.connect(self.delete_group_button, QtCore.SIGNAL('clicked()'), self.on_delete_group)
else:
self.name_set.clicked.connect(self.on_set_name)
self.name_button.clicked.connect(self.on_default_name)
self.elements_button.clicked.connect(self.on_default_elements)
self.add_button.clicked.connect(self.on_add)
self.remove_button.clicked.connect(self.on_remove)
self.table.itemClicked.connect(self.on_update_active_key)
self.ok_button.clicked.connect(self.on_ok)
self.set_as_main_button.clicked.connect(self.on_set_as_main)
self.create_group_button.clicked.connect(self.on_create_group)
self.delete_group_button.clicked.connect(self.on_delete_group)
def on_create_group(self):
irow = self.nrows
new_key = 'Group %s' % irow
while new_key in self.keys:
irow += 1
new_key = 'Group %s' % irow
irow = self.nrows
self.keys.append(new_key)
group = Group(
new_key,
element_str='',
elements_pound=self.elements_pound,
editable=True)
self.out_data[irow] = group
self.table.reset()
self.table.addItems(self.keys)
self.nrows += 1
#----------------------------------
# update internal parameters
#self.out_data = items
if self.imain > self.active_key:
self.imain += 1
#make the new group the default
self.active_key = self.nrows - 1
self.keys = [group.name for key, group in sorted(iteritems(self.out_data))]
self.recreate_table()
def recreate_table(self):
# update gui
self.table.clear()
self.table.addItems(self.keys)
item = self.table.item(self.imain)
bold = QtGui.QFont()
bold.setBold(True)
bold.setItalic(True)
item.setFont(bold)
self.table.update()
# update key
name = self.keys[self.active_key]
self._update_active_key_by_name(name)
def on_delete_group(self):
if self.active_key == 0:
return
#self.deleted_groups.add(self.imain)
items = {}
j = 0
for i, key in sorted(iteritems(self.out_data)):
if i != self.active_key:
items[j] = key
j += 1
# update internal parameters
self.out_data = items
if self.imain >= self.active_key:
self.imain = max(0, self.imain - 1)
self.active_key = max(0, self.active_key - 1)
self.nrows -= 1
self.keys = [group.name for key, group in sorted(iteritems(items))]
self.recreate_table()
# update key
name = self.keys[self.active_key]
self._update_active_key_by_name(name)
def on_set_as_main(self):
bold = QtGui.QFont()
bold.setBold(True)
bold.setItalic(True)
normal = QtGui.QFont()
normal.setBold(False)
normal.setItalic(False)
obj = self.table.item(self.imain)
obj.setFont(normal)
self.imain = self.active_key
obj = self.table.item(self.imain)
obj.setFont(bold)
group = self.out_data[self.imain]
self._default_elements = group.element_str
self._default_name = group.name
if self.win_parent is not None:
# we're not testing the menu
self.win_parent.post_group(group)
def closeEvent(self, event):
event.accept()
def on_add(self):
eids, is_valid = self.check_patran_syntax(self.add_edit, pound=self.elements_pound)
#adict, is_valid = self.check_patran_syntax_dict(self.add_edit)
if not is_valid:
#self.add_edit.setStyleSheet("QLineEdit{background: red;}")
return
self.eids = unique(hstack([self.eids, eids]))
#self.eids = _add(adict, ['e', 'elem', 'element'], self.eids)
#self.cids = _add(adict, ['c', 'cid', 'coord'], self.cids)
self._apply_cids_eids()
self.add_edit.clear()
self.add_edit.setStyleSheet("QLineEdit{background: white;}")
def _apply_cids_eids(self):
#ctext = _get_collapsed_text(self.cids)
etext = _get_collapsed_text(self.eids)
#self.coords_edit.setText(str(ctext.lstrip()))
self.elements_edit.setText(str(etext.lstrip()))
self.out_data[self.active_key].element_ids = self.eids
def on_remove(self):
eids, is_valid = self.check_patran_syntax(self.remove_edit)
#adict, is_valid = self.check_patran_syntax_dict(self.remove_edit)
if not is_valid:
#self.remove_edit.setStyleSheet("QLineEdit{background: red;}")
return
#self.eids = _remove(adict, ['e', 'elem', 'element'], self.eids)
#self.cids = _remove(adict, ['c', 'cid', 'coord'], self.cids)
self.eids = setdiff1d(self.eids, eids)
self._apply_cids_eids()
self.remove_edit.clear()
self.remove_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_name(self):
name = str(self._default_name)
self.name_edit.setText(name)
self.name_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_elements(self):
element_str = str(self._default_elements)
self.elements_edit.setText(element_str)
self.elements_edit.setStyleSheet("QLineEdit{background: white;}")
group = self.out_data[self.active_key]
group.element_str = element_str
def check_patran_syntax(self, cell, pound=None):
text = str(cell.text())
try:
values = parse_patran_syntax(text, pound=pound)
cell.setStyleSheet("QLineEdit{background: white;}")
return values, True
except ValueError as e:
cell.setStyleSheet("QLineEdit{background: red;}")
cell.setToolTip(str(e))
return None, False
def check_patran_syntax_dict(self, cell, pound=None):
text = str(cell.text())
try:
value = parse_patran_syntax_dict(text)
cell.setStyleSheet("QLineEdit{background: white;}")
cell.setToolTip('')
return value, True
except (ValueError, SyntaxError, KeyError) as e:
cell.setStyleSheet("QLineEdit{background: red;}")
cell.setToolTip(str(e))
return None, False
def check_float(self, cell):
text = cell.text()
try:
value = float(text)
cell.setStyleSheet("QLineEdit{background: white;}")
cell.setToolTip('')
return value, True
except ValueError:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
def check_name(self, cell):
text = str(cell.text()).strip()
if len(text):
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
if self._default_name != text:
if self._default_name in self.out_data:
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
def check_format(self, cell):
text = str(cell.text())
is_valid = True
if len(text) < 2:
is_valid = False
elif 's' in text.lower():
is_valid = False
elif '%' not in text[0]:
is_valid = False
elif text[-1].lower() not in ['g', 'f', 'i', 'e']:
is_valid = False
try:
text % 1
text % .2
text % 1e3
text % -5.
text % -5
except ValueError:
is_valid = False
try:
text % 's'
is_valid = False
except TypeError:
pass
if is_valid:
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
def on_validate(self):
name, flag0 = self.check_name(self.name_edit)
elements, flag1 = self.check_patran_syntax(self.elements_edit,
pound=self.elements_pound)
#coords_value, flag2 = self.check_patran_syntax(self.coords_edit,
#pound=self.coords_pound)
if flag0 and flag1:
self._default_name = name
self._default_elements = self.eids
self.out_data['clicked_ok'] = True
return True
return False
def on_apply(self, force=False):
passed = self.on_validate()
if passed or force:
self.win_parent.on_modify_group(self.out_data)
def on_ok(self):
passed = self.on_validate()
if passed:
self.out_data['close'] = True
self.out_data['clicked_ok'] = True
self.out_data['clicked_cancel'] = False
self.close()
#self.destroy()
def on_cancel(self):
self.out_data['close'] = True
self.out_data['clicked_cancel'] = True
self.close()
def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_Escape:
self.on_cancel()
def on_update_active_key(self, index):
self.update_active_key(index)
#str(index.text())
def update_active_key(self, index):
#old_obj = self.out_data[self.imain]
name = str(index.text())
self._update_active_key_by_name(name)
def _update_active_key_by_name(self, name):
if name in self.keys:
self.active_key = self.keys.index(name)
else:
# we (hopefully) just removed a row
#self.active_key = self.keys[self.active_key]
pass
self.name_edit.setText(name)
obj = self.out_data[self.active_key]
self.eids = parse_patran_syntax(obj.element_str, pound=obj.elements_pound)
self._default_elements = obj.element_str
self._default_name = name
self._apply_cids_eids()
self.set_as_main_button.setEnabled(True)
if name in ['main', 'anti-main']:
self.name.setEnabled(False)
self.name_set.setEnabled(False)
self.name_edit.setEnabled(False)
self.name_button.setEnabled(False)
self.elements.setEnabled(False)
self.elements_button.setEnabled(False)
self.elements_edit.setEnabled(False)
self.add.setEnabled(False)
self.add_button.setEnabled(False)
self.add_edit.setEnabled(False)
self.remove.setEnabled(False)
self.remove_button.setEnabled(False)
self.remove_edit.setEnabled(False)
self.delete_group_button.setEnabled(False)
if name == 'anti-main':
self.set_as_main_button.setEnabled(False)
#self.apply_button.setEnabled(False)
#self.ok_button.setEnabled(False)
else:
self.name.setEnabled(True)
self.name_set.setEnabled(True)
self.name_edit.setEnabled(True)
self.name_button.setEnabled(True)
self.elements.setEnabled(True)
self.elements_button.setEnabled(True)
self.add.setEnabled(True)
self.add_button.setEnabled(True)
self.add_edit.setEnabled(True)
self.remove.setEnabled(True)
self.remove_button.setEnabled(True)
self.remove_edit.setEnabled(True)
self.delete_group_button.setEnabled(True)
class I2CWidget(QWidget):
def __init__(self, status, actions):
super (I2CWidget, self).__init__()
self.status = status
self.actions = actions
self.row_add_action = QAction("Add Row", self)
self.row_add_action.triggered.connect(self.add_row)
self.row_delete_action = QAction("Delete Row", self)
self.row_delete_action.triggered.connect(self.remove_row)
self.default_script_list = QListWidget()
self.default_script_list.setMaximumWidth(150)
self.default_script_list.itemDoubleClicked.connect(self.default_script_load_double_clicked)
self.setWindowTitle("Standalone I2C Widget")
layout = QHBoxLayout()
self.load_callback = None
self.toolbar = QToolBar()
self.toolbar.setMaximumWidth(150)
self.toolbar.setSizePolicy(Qt.QSizePolicy.Maximum, Qt.QSizePolicy.Maximum)
self.tools_layout= QVBoxLayout()
self.save_loader = SaveLoader(extensions = ["csv"],
initial_file = "i2c_config_file")
self.toolbar.setOrientation(QtCore.Qt.Vertical)
self.toolbar.addAction(self.row_add_action)
self.toolbar.addAction(self.row_delete_action)
self.tools_layout.addWidget(self.toolbar)
self.tools_layout.addWidget(QLabel("Default Scripts"))
self.tools_layout.addWidget(self.default_script_list)
default_script_load = QPushButton("Load")
default_script_load.clicked.connect(self.default_script_load_clicked)
self.tools_layout.addWidget(default_script_load)
self.tab_view = QTabWidget()
self.init_table = I2CTable(self.status, self.actions, loop = False)
self.loop_table = I2CTable(self.status, self.actions, loop = True)
self.tab_view.addTab(self.init_table, "Start")
self.tab_view.addTab(self.loop_table, "Loop")
self.control_view = I2CControlView(self.status, self.actions)
self.actions.i2c_update_view.connect(self.update_i2c_transactions)
layout.addLayout(self.tools_layout)
io_layout = QVBoxLayout()
io_layout.addWidget(self.save_loader)
name_desc_layout = QHBoxLayout()
self.config_name = QLineEdit("Name")
self.config_name.setMinimumWidth(100)
self.config_name.setSizePolicy(Qt.QSizePolicy.Preferred, Qt.QSizePolicy.Preferred)
self.config_desc = QLineEdit("Description")
name_desc_layout.addWidget(self.config_name)
name_desc_layout.addWidget(self.config_desc)
io_layout.addLayout(name_desc_layout)
io_layout.addWidget(self.tab_view)
layout.addLayout(io_layout)
#layout.addWidget(self.tab_view)
layout.addWidget(self.control_view)
self.setLayout(layout)
self.actions.i2c_update_read_view.connect(self.update_read_view)
self.init_read_data = None
self.loop_read_data = None
self.read_timer = QTimer(self)
self.read_timer.setInterval(SINGLE_SHOT_TIMEOUT)
self.read_timer.setSingleShot(True)
def get_config_name(self):
return self.config_name.text()
def set_config_name(self, name):
self.config_name.setText(name)
def get_config_description(self):
return self.config_desc.text()
def set_config_description(self, description):
self.config_desc.setText(description)
def add_row(self):
if self.tab_view.currentWidget() is self.loop_table:
self.actions.i2c_row_add.emit(True)
else:
self.actions.i2c_row_add.emit(False)
def remove_row(self):
if self.tab_view.currentWidget() is self.loop_table:
self.actions.i2c_row_delete.emit(True)
else:
self.actions.i2c_row_delete.emit(False)
def update_i2c_transactions(self, loop, transactions):
if not loop:
self.update_i2c_init_transactions(transactions)
else:
self.update_i2c_loop_transactions(transactions)
def update_i2c_init_transactions(self, transactions):
self.init_table.update_i2c_transactions(transactions)
def update_i2c_loop_transactions(self, transactions):
self.loop_table.update_i2c_transactions(transactions)
def set_save_callback(self, callback):
self.save_loader.set_save_callback(callback)
def set_load_callback(self, callback):
self.save_loader.set_load_callback(callback)
def get_filename(self):
return self.save_loader.get_filename()
def default_script_load_clicked(self):
item = self.default_script_list.currentItem()
if item is not None:
filename = os.path.join(DEFAULT_SCRIPT_PATH, str(item.text()))
if self.load_callback is not None:
self.load_callback(filename)
#print "Item: %s" % filename
def set_load_default_callback(self, callback):
self.load_callback = callback
def default_script_load_double_clicked(self, item):
self.default_script_load_clicked()
def load_default_scripts(self):
files = os.listdir(DEFAULT_SCRIPT_PATH)
self.default_script_list.clear()
self.default_script_list.addItems(files)
self.default_script_list.setCurrentRow(0)
def singleshot_event(self):
#print "update I2C Read: in thread: %s" % str(QThread.currentThread().objectName())
if self.init_read_data is not None:
self.init_table.update_read_data(self.init_read_data)
self.init_read_data = None
if self.loop_read_data is not None:
self.loop_table.update_read_data(self.loop_read_data)
self.loop_read_data = None
def update_read_view(self, loop, read_data):
#print "read timer active: %s" % str(self.read_timer.isActive())
if loop:
self.loop_read_data = read_data
else:
self.init_read_data = read_data
if not self.read_timer.isActive():
self.read_timer.singleShot(SINGLE_SHOT_TIMEOUT, self.singleshot_event)
self.read_timer.start()
class ListBox(QWidget):
def __init__(self, parent):
QWidget.__init__(self, parent)
while not isinstance(parent, QDialog):
parent = parent.parent()
self.setObjectName("ListBox" + str(len(parent.findChildren(ListBox))))
self.hLayoutBoxPanel = QHBoxLayout(self)
self.hLayoutBoxPanel.setSpacing(0)
self.hLayoutBoxPanel.setContentsMargins(3, 3, 3, 3)
self.hLayoutBoxPanel.setObjectName(("hLayoutBoxPanel"))
self.frameBoxPanel = QFrame(self)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.frameBoxPanel.sizePolicy().hasHeightForWidth())
self.frameBoxPanel.setSizePolicy(sizePolicy)
self.frameBoxPanel.setFrameShape(QFrame.NoFrame)
self.frameBoxPanel.setFrameShadow(QFrame.Raised)
self.frameBoxPanel.setObjectName(("frameBoxPanel"))
self.hLayoutframeBoxPanel = QHBoxLayout(self.frameBoxPanel)
self.hLayoutframeBoxPanel.setSpacing(0)
self.hLayoutframeBoxPanel.setMargin(0)
self.hLayoutframeBoxPanel.setObjectName(("hLayoutframeBoxPanel"))
self.captionLabel = QLabel(self.frameBoxPanel)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.captionLabel.sizePolicy().hasHeightForWidth())
self.captionLabel.setSizePolicy(sizePolicy)
self.captionLabel.setMinimumSize(QSize(200, 0))
self.captionLabel.setMaximumSize(QSize(200, 16777215))
font = QFont()
font.setBold(False)
font.setWeight(50)
self.captionLabel.setFont(font)
self.captionLabel.setObjectName(("captionLabel"))
self.hLayoutframeBoxPanel.addWidget(self.captionLabel)
self.listBox = QListWidget(self.frameBoxPanel)
self.listBox.setEnabled(True)
font = QFont()
font.setBold(False)
font.setWeight(50)
self.listBox.setFont(font)
self.listBox.setObjectName(("listBox"))
# self.listBox.setText("0.0")
self.hLayoutframeBoxPanel.addWidget(self.listBox)
self.imageButton = QToolButton(self.frameBoxPanel)
self.imageButton.setText((""))
icon = QIcon()
icon.addPixmap(QPixmap(("Resource/convex_hull.png")), QIcon.Normal,
QIcon.Off)
self.imageButton.setIcon(icon)
self.imageButton.setObjectName(("imageButton"))
self.imageButton.setVisible(False)
self.hLayoutframeBoxPanel.addWidget(self.imageButton)
self.hLayoutBoxPanel.addWidget(self.frameBoxPanel)
self.listBox.currentRowChanged.connect(self.listBoxChanged)
self.imageButton.clicked.connect(self.imageButtonClicked)
self.captionUnits = ""
self.hasObject = False
self.objectList = []
self.captionLabel.setVisible(False)
def get_Count(self):
return self.listBox.count()
Count = property(get_Count, None, None, None)
def method_3(self, string_0):
return self.listBox.row(self.listBox.findItems(string_0)[0])
def method_11(self, string_0):
if (self.IsEmpty):
return "%s%s\t" % (string_0, self.Caption)
return "%s%s\t%s %s" % (string_0, self.Caption, self.Value,
self.CaptionUnits)
def listBoxChanged(self, index):
i = index
self.emit(SIGNAL("Event_0"), self)
def IndexOf(self, item):
if isinstance(item, str):
return self.listBox.row(self.listBox.findItems(item)[0])
else:
return self.listBox.row(
self.listBox.findItems(item.ToString())[0])
def Contains(self, item):
compStr = None
if isinstance(item, str):
compStr = item
elif isinstance(item, float) or isinstance(item, int):
compStr = str(item)
else:
compStr = item.ToString()
for i in range(self.listBox.count()):
comboItemstr = self.listBox.item(i).text()
if compStr == comboItemstr:
return True
return False
def Clear(self):
self.listBox.clear()
self.objectList = []
self.hasObject = False
def Add(self, item):
if not isinstance(item, str) and not isinstance(item, QString):
self.listBox.addItem(item.ToString())
self.objectList.append(item)
self.hasObject = True
return
self.listBox.addItem(item)
self.hasObject = False
return self.listBox.count() - 1
def Insert(self, index, item):
if not isinstance(item, str):
self.listBox.insertItem(index, item.ToString())
self.objectList.insert(index, item)
self.hasObject = True
return
self.listBox.insertItem(index, item)
self.hasObject = False
def imageButtonClicked(self):
self.emit(SIGNAL("Event_3"), self)
def get_Caption(self):
caption = self.captionLabel.text()
findIndex = caption.indexOf("(")
if findIndex > 0:
val = caption.left(findIndex)
return val
return caption
def set_Caption(self, captionStr):
if captionStr == "":
self.captionLabel.setText("")
self.LabelWidth = 0
return
if self.CaptionUnits != "" and self.CaptionUnits != None:
self.captionLabel.setText(captionStr + "(" +
str(self.CaptionUnits) + ")" + ":")
else:
self.captionLabel.setText(captionStr + ":")
Caption = property(get_Caption, set_Caption, None, None)
def get_CaptionUnits(self):
return self.captionUnits
def set_CaptionUnits(self, captionUnits):
self.captionUnits = captionUnits
CaptionUnits = property(get_CaptionUnits, set_CaptionUnits, None, None)
def set_ButtonVisible(self, bool):
self.imageButton.setVisible(bool)
ButtonVisible = property(None, set_ButtonVisible, None, None)
# def get_Value(self):
# return self.listBox.currentIndex()
#
# def set_Value(self, value):
# try:
# self.listBox.setCurrentIndex(value)
# except:
# self.textBox.setText("")
# Value = property(get_Value, set_Value, None, None)
# def get_IsEmpty(self):
# return self.listBox.currentText() == "" or self.listBox.currentIndex() == -1
# IsEmpty = property(get_IsEmpty, None, None, None)
# def get_ReadOnly(self):
# return self.listBox.isReadOnly()
# # def set_ReadOnly(self, bool):
# # self.listBox.setR.setReadOnly(bool)
# # ReadOnly = property(get_ReadOnly, set_ReadOnly, None, None)
def set_LabelWidth(self, width):
self.captionLabel.setMinimumSize(QSize(width, 0))
self.captionLabel.setMaximumSize(QSize(width, 16777215))
LabelWidth = property(None, set_LabelWidth, None, None)
def set_Width(self, width):
self.listBox.setMinimumSize(QSize(width, 0))
self.listBox.setMaximumSize(QSize(width, 16777215))
Width = property(None, set_Width, None, None)
def set_Button(self, imageName):
if imageName == None or imageName == "":
self.imageButton.setVisible(False)
return
icon = QIcon()
icon.addPixmap(QPixmap(("Resource/" + imageName)), QIcon.Normal,
QIcon.Off)
self.imageButton.setIcon(icon)
self.imageButton.setVisible(True)
Button = property(None, set_Button, None, None)
def get_SelectedIndex(self):
try:
return self.listBox.currentRow()
except:
return 0
def set_SelectedIndex(self, index):
if self.listBox.count() == 0:
return
if index > self.listBox.count() - 1:
self.listBox.setCurrentRow(0)
else:
self.listBox.setCurrentRow(index)
SelectedIndex = property(get_SelectedIndex, set_SelectedIndex, None, None)
# def get_Value(self):
# return self.listBox.currentIndex()
# def set_Value(self, valueStr):
# if self.listBox.count() == 0:
# return
# self.listBox.setCurrentIndex(self.listBox.findText(valueStr))
# Value = property(get_Value, set_Value, None, None)
def get_Items(self):
if self.hasObject:
return self.objectList
itemList = []
if self.listBox.count() > 0:
for i in range(self.listBox.count()):
itemList.append(self.listBox.item(i).text())
return itemList
def set_AddItems(self, strList):
if len(strList) != 0 and not isinstance(
strList[0], str) and not isinstance(strList[0], QString):
for obj in strList:
self.listBox.addItem(obj.ToString())
self.objectList.append(obj)
self.hasObject = True
return
self.listBox.addItems(strList)
Items = property(get_Items, set_AddItems, None, None)
def get_Enabled(self):
return self.listBox.isEnabled()
def set_Enabled(self, bool):
self.listBox.setEnabled(bool)
Enabled = property(get_Enabled, set_Enabled, None, None)
def get_Visible(self):
return self.isVisible()
def set_Visible(self, bool):
self.setVisible(bool)
Visible = property(get_Visible, set_Visible, None, None)
def get_SelectedItem(self):
if self.listBox.count() == 0:
return None
if self.hasObject:
return self.objectList[self.SelectedIndex]
return self.listBox.currentItem().text()
# def set_SelectedItem(self, val):
# index = self.listBox.findText(val)
# self.listBox.setCurrentIndex(index)
SelectedItem = property(get_SelectedItem, None, None, None)
class GitStatus(QDialog):
def __init__(self, plugin, git, path):
QDialog.__init__(self)
self.git = git
self.plugin = plugin
self.setWindowTitle('Git status')
layout = QGridLayout(self)
branches = self.git.branch(unicode(path))
self.s_branches = QListWidget()
if len(branches) > 0:
self.s_branches.addItems(branches[1:])
self.actual_branch = QLabel("<h2>{0}</h2>".format(branches[0]))
else:
self.actual_branch = QLabel()
branch = QLabel("<h2>Branches</h2>")
change_branch = QPushButton("Change to")
merge_branches = QPushButton("Merge branch")
H = QHBoxLayout()
delete_branch = QPushButton("Delete branch")
add_branch = QPushButton("Add branch")
H.addWidget(add_branch)
H.addWidget(delete_branch)
self.lists = []
no_staged = QLabel("<h2>No staged</h2>")
untracked_files = QLabel("Untracked files")
self.untracked_files = QListWidget()
self.lists.append(self.untracked_files)
modified_files = QLabel("Modified files")
self.modified_files = QListWidget()
self.lists.append(self.modified_files)
deleted_files = QLabel("Deleted files")
self.deleted_files = QListWidget()
self.lists.append(self.deleted_files)
staged = QLabel("<h2>Staged</h2>")
added_files = QLabel("Added files")
self.added_files = QListWidget()
self.lists.append(self.added_files)
s_modified_files = QLabel("Modified files")
self.s_modified_files = QListWidget()
self.lists.append(self.s_modified_files)
s_deleted_files = QLabel("Deleted files")
self.s_deleted_files = QListWidget()
self.lists.append(self.s_deleted_files)
layout.addWidget(self.actual_branch, 0, 0, Qt.AlignHCenter)
layout.addWidget(change_branch, 1, 0)
layout.addWidget(merge_branches, 2, 0)
layout.addWidget(no_staged, 3, 0)
layout.addWidget(untracked_files, 4, 0)
layout.addWidget(self.untracked_files, 5, 0)
layout.addWidget(modified_files, 6, 0)
layout.addWidget(self.modified_files, 7, 0)
layout.addWidget(deleted_files, 8, 0)
layout.addWidget(self.deleted_files, 9, 0)
layout.addWidget(branch, 0, 1)
layout.addWidget(self.s_branches, 1, 1)
layout.addLayout(H, 2, 1)
layout.addWidget(staged, 3, 1)
layout.addWidget(added_files, 4, 1)
layout.addWidget(self.added_files, 5, 1)
layout.addWidget(s_modified_files, 6, 1)
layout.addWidget(self.s_modified_files, 7, 1)
layout.addWidget(s_deleted_files, 8, 1)
layout.addWidget(self.s_deleted_files, 9, 1)
self.fill(self.git.no_staged["?"], self.untracked_files)
self.fill(self.git.no_staged["M"], self.modified_files)
self.fill(self.git.no_staged["D"], self.deleted_files)
self.fill(self.git.staged["A"], self.added_files)
self.fill(self.git.staged["M"], self.s_modified_files)
self.fill(self.git.staged["D"], self.s_deleted_files)
self.staged_b = QPushButton('Stage files', self)
self.unstage_b = QPushButton("Unstage files", self)
self.commit_b = QPushButton('Commit files', self)
self.uncommit_b = QPushButton("Uncommit files", self)
layout.addWidget(self.staged_b, 10, 0)
layout.addWidget(self.unstage_b, 11, 0)
layout.addWidget(self.commit_b, 10, 1)
layout.addWidget(self.uncommit_b, 11, 1)
self.setLayout(layout)
self.connect(self.staged_b, SIGNAL('clicked()'), self.add)
self.connect(self.unstage_b, SIGNAL('clicked()'), self.unstage)
self.connect(self.commit_b, SIGNAL('clicked()'), self.commit)
self.connect(self.uncommit_b, SIGNAL('clicked()'), self.uncommit)
self.connect(change_branch, SIGNAL("clicked()"), self.change_branch)
self.connect(add_branch, SIGNAL("clicked()"), self.add_branch)
self.connect(delete_branch, SIGNAL("clicked()"), self.delete_branch)
self.connect(merge_branches, SIGNAL("clicked()"), self.merge_branches)
def fill(self, a_list, widget_list):
for x in a_list:
item = QListWidgetItem()
widget_list.addItem(item)
check_box = QCheckBox(x)
widget_list.setItemWidget(item, check_box)
def add(self):
path = self.plugin.editor.get_project_owner()
for pos in reversed(xrange(self.untracked_files.count())):
item = self.untracked_files.item(pos)
widget = self.untracked_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.add(path, text)
self.untracked_files.removeItemWidget(item)
self.untracked_files.takeItem(pos)
item = QListWidgetItem()
self.added_files.addItem(item)
check_box = QCheckBox(text)
self.added_files.setItemWidget(item, check_box)
for pos in reversed(xrange(self.modified_files.count())):
item = self.modified_files.item(pos)
widget = self.modified_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.add(path, widget.text())
self.modified_files.removeItemWidget(item)
self.modified_files.takeItem(pos)
item = QListWidgetItem()
self.s_modified_files.addItem(item)
check_box = QCheckBox(text)
self.s_modified_files.setItemWidget(item, check_box)
for pos in reversed(xrange(self.deleted_files.count())):
item = self.deleted_files.item(pos)
widget = self.deleted_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.add(path, widget.text())
self.deleted_files.removeItemWidget(item)
self.deleted_files.takeItem(pos)
item = QListWidgetItem()
self.s_deleted_files.addItem(item)
check_box = QCheckBox(text)
self.s_deleted_files.setItemWidget(item, check_box)
def unstage(self):
path = self.plugin.editor.get_project_owner()
for pos in reversed(xrange(self.untracked_files.count())):
item = self.untracked_files.item(pos)
widget = self.untracked_files.itemWidget(item)
if widget.isChecked():
self.git.unstage(path, widget.text())
self.untracked_files.removeItemWidget(item)
self.untracked_files.takeItem(pos)
for pos in reversed(xrange(self.modified_files.count())):
item = self.modified_files.item(pos)
widget = self.modified_files.itemWidget(item)
if widget.isChecked():
self.git.unstage(path, widget.text())
self.modified_files.removeItemWidget(item)
self.modified_files.takeItem(pos)
for pos in reversed(xrange(self.deleted_files.count())):
item = self.deleted_files.item(pos)
widget = self.deleted_files.itemWidget(item)
if widget.isChecked():
self.git.unstage(path, widget.text())
self.deleted_files.removeItemWidget(item)
self.deleted_files.takeItem(pos)
def commit(self):
msg = QInputDialog.getText(self, "Commit message", "Commit Message:")
if msg[1] == False:
return(0)
path = self.plugin.editor.get_project_owner()
for pos in reversed(xrange(self.added_files.count())):
item = self.added_files.item(pos)
widget = self.added_files.itemWidget(item)
if widget.isChecked():
self.git.commit(path, str(widget.text()), msg[0])
self.added_files.removeItemWidget(item)
self.added_files.takeItem(pos)
for pos in reversed(xrange(self.s_modified_files.count())):
item = self.s_modified_files.item(pos)
widget = self.s_modified_files.itemWidget(item)
if widget.isChecked():
self.git.commit(path, widget.text(), msg[0])
self.s_modified_files.removeItemWidget(item)
self.s_modified_files.takeItem(pos)
for pos in reversed(xrange(self.s_deleted_files.count())):
item = self.s_deleted_files.item(pos)
widget = self.s_deleted_files.itemWidget(item)
if widget.isChecked():
self.git.commit(path, widget.text(), msg[0])
self.s_deleted_files.takeItem(pos)
self.s_deleted_files.removeItemWidget(item)
def uncommit(self):
path = self.plugin.editor.get_project_owner()
for pos in reversed(xrange(self.added_files.count())):
item = self.added_files.item(pos)
widget = self.added_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.uncommit(path, str(widget.text()))
self.added_files.removeItemWidget(item)
self.added_files.takeItem(pos)
item = QListWidgetItem()
self.untracked_files.addItem(item)
check_box = QCheckBox(text)
self.untracked_files.setItemWidget(item, check_box)
for pos in reversed(xrange(self.s_modified_files.count())):
item = self.s_modified_files.item(pos)
widget = self.s_modified_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.uncommit(path, widget.text())
self.s_modified_files.removeItemWidget(item)
self.s_modified_files.takeItem(pos)
item = QListWidgetItem()
self.modified_files.addItem(item)
check_box = QCheckBox(text)
self.modified_files.setItemWidget(item, check_box)
for pos in reversed(xrange(self.s_deleted_files.count())):
item = self.s_deleted_files.item(pos)
widget = self.s_deleted_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.uncommit(path, widget.text())
self.s_deleted_files.removeItemWidget(item)
self.s_deleted_files.takeItem(pos)
item = QListWidgetItem()
self.deleted_files.addItem(item)
check_box = QCheckBox(text)
self.deleted_files.setItemWidget(item, check_box)
def change_branch(self):
path = self.plugin.editor.get_project_owner()
item = self.s_branches.currentItem()
if item and not self.something():
text = item.text()
self.git.change_branch(path, text)
self.s_branches.clear()
self.s_branches.addItems(self.git.branch(unicode(path))[1:])
self.actual_branch.setText("<h2>{0}<h2>".format(text))
if self.something():
v = QMessageBox()
v.setText("Error: you have unsaved changes")
v.setIcon(v.Warning)
v.exec_()
def add_branch(self):
path = self.plugin.editor.get_project_owner()
msg = QInputDialog.getText(self, "New branch", "Branch Name:")
if msg[1] == False:
return(0)
self.git.add_branch(path, msg[0])
self.s_branches.clear()
self.s_branches.addItems(self.git.branch(unicode(path))[1:])
def delete_branch(self):
path = self.plugin.editor.get_project_owner()
item = self.s_branches.currentItem()
if item:
text = str(item.text())
call = self.git.delete_branch(path, text)
if not call:
self.s_branches.clear()
self.s_branches.addItems(self.git.branch(unicode(path))[1:])
else:
m = QMessageBox()
m.setText("<h2>" + call + "</h2>")
m.setInformativeText("Force deletion?")
m.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
m.setDefaultButton(QMessageBox.Cancel)
c = m.exec_()
if c == QMessageBox.Ok:
self.git.force_delete_branch(path, text)
self.s_branches.clear()
self.s_branches.addItems(self.git.branch(unicode(path))[1:])
def merge_branches(self):
path = self.plugin.editor.get_project_owner()
item = self.s_branches.currentItem()
if item:
text = str(item.text())
call = self.git.merge_branches(path, text)
if call:
m = QMessageBox()
m.setText(call)
m.setInformativeText("Unknown")
m.setIcon(m.Critical)
m.exec_()
def something(self):
for x in self.lists:
if x.count() > 0:
return True
return False
class StringListDlg(QDialog):
acceptedList = Signal(QStringList)
def __init__(self, name, stringlist=None, parent=None):
super(StringListDlg, self).__init__(parent)
self.name = name
self.create_widgets(stringlist)
self.layout_widgets()
self.setWindowTitle("Edit {0} List".format(self.name))
def create_widgets(self, stringlist):
self.listWidget = QListWidget()
if stringlist is not None:
self.listWidget.addItems(stringlist)
self.listWidget.setCurrentRow(0)
def layout_widgets(self):
buttonLayout = QVBoxLayout()
for text, slot in (("&Add...", self.add), ("&Edit...", self.edit),
("&Remove...", self.remove), ("&Up", self.up),
("&Down", self.down), ("&Sort",
self.listWidget.sortItems),
("Close", self.accept)):
button = QPushButton(text)
if not MAC:
button.setFocusPolicy(Qt.NoFocus)
if text == "Close":
buttonLayout.addStretch()
buttonLayout.addWidget(button)
button.clicked.connect(slot)
layout = QHBoxLayout()
layout.addWidget(self.listWidget)
layout.addLayout(buttonLayout)
self.setLayout(layout)
def add(self):
row = self.listWidget.currentRow()
title = "Add {0}".format(self.name)
string, ok = QInputDialog.getText(self, title, title)
if ok and not string.isEmpty():
self.listWidget.insertItem(row, string)
def edit(self):
row = self.listWidget.currentRow()
item = self.listWidget.item(row)
if item is not None:
title = "Edit {0}".format(self.name)
string, ok = QInputDialog.getText(self, title, title,
QLineEdit.Normal, item.text())
if ok and not string.isEmpty():
item.setText(string)
def remove(self):
row = self.listWidget.currentRow()
item = self.listWidget.item(row)
if item is None:
return
reply = QMessageBox.question(
self, "Remove {0}".format(self.name),
"Remove {0} `{1}'?".format(self.name, unicode(item.text())),
QMessageBox.Yes | QMessageBox.No)
if reply == QMessageBox.Yes:
item = self.listWidget.takeItem(row)
del item
def up(self):
row = self.listWidget.currentRow()
if row >= 1:
item = self.listWidget.takeItem(row)
self.listWidget.insertItem(row - 1, item)
self.listWidget.setCurrentItem(item)
def down(self):
row = self.listWidget.currentRow()
if row < self.listWidget.count() - 1:
item = self.listWidget.takeItem(row)
self.listWidget.insertItem(row + 1, item)
self.listWidget.setCurrentItem(item)
def reject(self):
self.accept()
def accept(self):
self.stringlist = QStringList()
for row in range(self.listWidget.count()):
self.stringlist.append(self.listWidget.item(row).text())
self.acceptedList.emit(self.stringlist)
QDialog.accept(self)
class ListEdit(QWidget):
"""A widget to edit a list of items (e.g. a list of directories)."""
# emitted when anything changed in the listbox.
changed = pyqtSignal()
def __init__(self, *args, **kwargs):
QWidget.__init__(self, *args, **kwargs)
layout = QGridLayout(self)
self.setLayout(layout)
self.addButton = QPushButton(icons.get('list-add'), '')
self.editButton = QPushButton(icons.get('document-edit'), '')
self.removeButton = QPushButton(icons.get('list-remove'), '')
self.listBox = QListWidget()
layout.setContentsMargins(1, 1, 1, 1)
layout.setSpacing(0)
layout.addWidget(self.listBox, 0, 0, 4, 1)
layout.addWidget(self.addButton, 0, 1)
layout.addWidget(self.editButton, 1, 1)
layout.addWidget(self.removeButton, 2, 1)
@self.addButton.clicked.connect
def addClicked():
item = self.createItem()
if self.openEditor(item):
self.addItem(item)
@self.editButton.clicked.connect
def editClicked():
item = self.listBox.currentItem()
item and self.editItem(item)
@self.removeButton.clicked.connect
def removeClicked():
item = self.listBox.currentItem()
if item:
self.removeItem(item)
@self.listBox.itemDoubleClicked.connect
def itemDoubleClicked(item):
item and self.editItem(item)
self.listBox.model().layoutChanged.connect(self.changed)
def updateSelection():
selected = bool(self.listBox.currentItem())
self.editButton.setEnabled(selected)
self.removeButton.setEnabled(selected)
self.changed.connect(updateSelection)
self.listBox.itemSelectionChanged.connect(updateSelection)
updateSelection()
app.translateUI(self)
def translateUI(self):
self.addButton.setText(_("&Add..."))
self.editButton.setText(_("&Edit..."))
self.removeButton.setText(_("&Remove"))
def createItem(self):
return QListWidgetItem()
def addItem(self, item):
self.listBox.addItem(item)
self.itemChanged(item)
self.changed.emit()
def removeItem(self, item):
self.listBox.takeItem(self.listBox.row(item))
self.changed.emit()
def editItem(self, item):
if self.openEditor(item):
self.itemChanged(item)
self.changed.emit()
def setCurrentItem(self, item):
self.listBox.setCurrentItem(item)
def setCurrentRow(self, row):
self.listBox.setCurrentRow(row)
def openEditor(self, item):
"""Opens an editor (dialog) for the item.
Returns True if the dialog was accepted and the item edited.
Returns False if the dialog was cancelled (the item must be left
unedited).
"""
pass
def itemChanged(self, item):
"""Called after an item has been added or edited.
Re-implement to do something at this moment if needed, e.g. alter the
text or display of other items.
"""
pass
def setValue(self, strings):
"""Sets the listbox to a list of strings."""
self.listBox.clear()
self.listBox.addItems(strings)
self.changed.emit()
def value(self):
"""Returns the list of paths in the listbox."""
return [
self.listBox.item(i).text() for i in range(self.listBox.count())
]
def setItems(self, items):
"""Sets the listbox to a list of items."""
self.listBox.clear()
for item in items:
self.listBox.addItem(item)
self.itemChanged(item)
self.changed.emit()
def items(self):
"""Returns the list of items in the listbox."""
return [self.listBox.item(i) for i in range(self.listBox.count())]
def clear(self):
"""Clears the listbox."""
self.listBox.clear()
self.changed.emit()
class TracklistWidget(QWidget):
requestUpload = pyqtSignal(list)
def __init__(self, parent=None):
super(TracklistWidget, self).__init__(parent)
self.tracklist = QListWidget(self)
self.tracklist.setSelectionMode(QListWidget.NoSelection)
self.upload_button = QPushButton(
QIcon(resource_path('images/strava-button.png')),
'Upload to Strava', self)
self.upload_button.setMinimumHeight(50)
self.upload_button.setIconSize(QSize(40, 40))
self.clear_password = QPushButton(
QIcon(resource_path('images/cross.png')),
'Clear password', self)
self.clear_password.setMinimumHeight(50)
self.clear_password.setIconSize(QSize(20, 20))
self.clear_password.hide()
self.upload_button.clicked.connect(self._onUploadClicked)
self._createLayout()
def setTracks(self, tracks):
self.tracklist.clear()
self.tracklist.addItems(tracks)
for i, name in enumerate(tracks):
self.tracklist.item(i).setCheckState(Qt.Unchecked)
self.tracklist.item(i).setSizeHint(QSize(200, 25))
if tracks:
self.tracklist.item(i).setCheckState(Qt.Checked)
self.upload_button.setEnabled(True)
else:
self.upload_button.setEnabled(False)
def _onUploadClicked(self):
ids = []
for i in range(self.tracklist.count()):
item = self.tracklist.item(i)
if item.checkState() == Qt.Checked:
ids.append(i)
if ids:
self.requestUpload.emit(ids)
def _createLayout(self):
l = QVBoxLayout()
l.addWidget(self.tracklist)
h = QHBoxLayout()
h.addWidget(self.upload_button)
h.addWidget(self.clear_password)
l.addLayout(h)
self.setLayout(l)
class OWMoleculeVisualizer(OWWidget):
settingsList = ["colorFragmets", "showFragments"]
contextHandlers = {
"": DomainContextHandler(
"",
[ContextField("selected_title_indices"),
ContextField("moleculeTitleAttributeList",
(DomainContextHandler.List +
DomainContextHandler.SelectedRequired +
DomainContextHandler.IncludeMetaAttributes),
selected="selectedMoleculeTitleAttrs"),
ContextField("smiles_var",
DomainContextHandler.Required +
DomainContextHandler.IncludeMetaAttributes)],
maxAttributesToPickle=1000)
}
def __init__(self, parent=None, signalManager=None,
title="Molecule visualizer"):
super(OWMoleculeVisualizer, self).__init__(parent, signalManager, title)
self.colorFragments = 1
self.showFragments = 0
self.selectedFragment = ""
self.moleculeSmiles = []
self.fragmentSmiles = []
self.defFragmentSmiles = []
self.smiles_var = 0
self.moleculeTitleAttr = 0
self.moleculeTitleAttributeList = []
self.selectedMoleculeTitleAttrs = []
self.fragmentSmilesAttr = 0
self.imageSize = 200
self.numColumns = 4
self.commitOnChange = 0
## GUI
box = OWGUI.widgetBox(self.controlArea, "Info", addSpace=True)
self.infoLabel = OWGUI.label(box, self, "Chemicals:")
box = OWGUI.radioButtonsInBox(
self.controlArea, self, "showFragments",
["Show molecules", "Show fragments"], "Show",
callback=self.updateitems
)
self.showFragmentsRadioButton = box.buttons[-1]
self.markFragmentsCheckBox = OWGUI.checkBox(
box, self, "colorFragments", "Mark fragments",
callback=self._update
)
box.setSizePolicy(
QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum))
OWGUI.separator(self.controlArea)
self.moleculeSmilesCombo = OWGUI.comboBox(
self.controlArea, self, "smiles_var",
"Molecule SMILES Attribute",
callback=self.updateitems
)
self.moleculeSmilesCombo.box.setSizePolicy(
QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum)
)
self.smiles_var_model = VariableListModel(parent=self)
self.moleculeSmilesCombo.setModel(self.smiles_var_model)
OWGUI.separator(self.controlArea)
box = OWGUI.widgetBox(self.controlArea, "Molecule Title Attributes",
addSpace=True)
self.title_var_view = QListView(
selectionMode=QListView.ExtendedSelection
)
self.title_var_model = VariableListModel(parent=self)
self.title_var_view.setModel(self.title_var_model)
self.title_var_view.selectionModel().selectionChanged.connect(
self._title_selection_changed
)
box.layout().addWidget(self.title_var_view)
OWGUI.separator(self.controlArea)
self.fragmentSmilesCombo = OWGUI.comboBox(
self.controlArea, self, "fragmentSmilesAttr",
"Fragment SMILES Attribute",
callback=self.updateFragmentsListBox
)
self.fragmentSmilesCombo.setModel(VariableListModel(parent=self))
self.fragmentSmilesCombo.box.setSizePolicy(
QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum)
)
OWGUI.separator(self.controlArea)
box = OWGUI.spin(self.controlArea, self, "imageSize", 50, 500, 10,
box="Image Size", callback=self._image_size_changed)
box.setSizePolicy(
QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum))
OWGUI.separator(self.controlArea)
box = OWGUI.widgetBox(self.controlArea, "Selection", addSpace=True)
OWGUI.checkBox(box, self, "commitOnChange", "Commit on change")
self.selectMarkedMoleculesButton = OWGUI.button(
box, self, "Select &matched molecules", self.select_marked
)
OWGUI.button(box, self, "&Commit", callback=self.commit, default=True)
OWGUI.separator(self.controlArea)
OWGUI.rubber(self.controlArea)
spliter = QSplitter(Qt.Vertical)
self.scrollArea = ScrollArea(spliter)
self.grid = GridWidget()
self.grid.selectionChanged.connect(self._on_selection_changed)
self.scrollArea.setWidget(self.grid)
self.scrollArea.setWidgetResizable(True)
self.mainArea.layout().addWidget(spliter)
if pybel:
self.listBox = QListWidget(spliter)
else:
self.listBox = QListWidget(None)
self.listBox.setHidden(True)
self.listBox.itemClicked.connect(self.fragmentSelection)
self.fragmentSmilesCombo.box.setDisabled(not pybel)
self.data = None
self.data_subset = []
self.fragment_data = None
self.resize(800, 600)
self.listBox.setMaximumHeight(150)
self.fragmentSmilesCombo.setDisabled(True)
self.selectMarkedMoleculesButton.setDisabled(True)
self.markFragmentsCheckBox.setDisabled(True)
self.showFragmentsRadioButton.setDisabled(True)
self.loadSettings()
if not pybel:
self.showFragments = 0
self.warning(10,
"Pybel module not installed. To view molecule fragments\n"
"please install openbabel python extension.")
self.__loop = None
def setMoleculeTable(self, data):
self.closeContext()
self.clear()
self.data = data
if data is not None:
all_vars = data.domain.variables + data.domain.get_metas().values()
text_vars = filter(
lambda v: isinstance(v, (Orange.feature.Discrete,
Orange.feature.String)),
all_vars)
var_scored = score_smiles_variables(data, text_vars)
self.smiles_var_model[:] = [var for var, _ in var_scored]
self.smiles_var = max(range(len(var_scored)),
key=lambda i: var_scored[i][1])
self.title_var_model[:] = all_vars
self.setFragmentSmilesCombo()
self.updateFragmentsListBox()
if self.data_subset:
try:
self.data_subset = self.data_subset.select(self.data.domain)
except Exception:
self.data_subset = []
self.openContext("", data)
else:
self.defFragmentSmiles = []
if not self.fragmentSmilesAttr:
self.listBox.clear()
self.openContext("", data)
self.send("Selected Molecules", None)
def setMoleculeSubset(self, data):
self.data_subset = data
try:
self.data_subset = self.data_subset.select(self.data.domain)
except Exception:
self.data_subset = []
def setFragmentTable(self, data):
self.fragment_data = data
if data is not None:
self.setFragmentSmilesCombo()
self.updateFragmentsListBox()
self.selectedFragment = ""
else:
self.setFragmentSmilesCombo()
self.updateFragmentsListBox()
self.fragmentSmilesCombo.setEnabled(data is not None)
def handleNewSignals(self):
self.updateitems()
def clear(self):
self.smiles_var_model[:] = []
self.title_var_model[:] = []
self.fragmentSmilesCombo.clear()
self.grid.clear()
self._widgets = []
self._items = []
if self.__loop is not None:
self.__loop.close()
self.__loop = None
def cleargrid(self):
self.grid.clear()
self._widgets = []
def _update_titles(self):
if self.data is None:
return
title_vars = [self.title_var_model[ind.row()]
for ind in self.title_var_view.selectedIndexes()]
for item, widget in zip(self._items, self._widgets):
inst = self.data[item.index]
text = " / ".join(map(str, (inst[var] for var in title_vars)))
widget.label.setText(text)
def setFragmentSmilesCombo(self):
if self.fragment_data:
candidates = score_smiles_variables(self.fragment_data)
else:
candidates = []
self.fragmentSmilesCombo.model()[:] = [v for v, _ in candidates]
if self.fragmentSmilesAttr > len(candidates):
self.fragmentSmilesAttr = 0
def updateFragmentsListBox(self):
if pybel is None:
return
fragvars = self.fragmentSmilesCombo.model()
if 0 <= self.fragmentSmilesAttr < len(fragvars):
fvar = fragvars[self.fragmentSmilesAttr]
else:
fvar = None
if fvar:
frags = [str(e[fvar]) for e in self.fragment_data
if not e[fvar].is_special()]
self.fragmentSmiles = [""] + frags
else:
self.fragmentSmiles = [""] + self.defFragmentSmiles
self.listBox.clear()
self.listBox.addItems(self.fragmentSmiles)
self.showFragmentsRadioButton.setDisabled(len(self.fragmentSmiles) == 1)
self.markFragmentsCheckBox.setDisabled(len(self.fragmentSmiles) == 1)
self.selectMarkedMoleculesButton.setDisabled(True)
def fragmentSelection(self, item):
if pybel is None:
return
index = self.listBox.indexFromItem(item).row()
if index == -1:
index = 0
self.selectedFragment = self.fragmentSmiles[index]
self.selectMarkedMoleculesButton.setEnabled(bool(self.selectedFragment))
self.markFragmentsCheckBox.setEnabled(bool(self.selectedFragment))
if not self.showFragments and self.colorFragments:
self._update()
def _title_text(self, index):
title_vars = [self.title_var_model[ind.row()]
for ind in self.title_var_view.selectedIndexes()]
inst = self.data[index]
return " / ".join(map(str, (inst[var] for var in title_vars)))
def _items_from_var(self, var):
if self.data is None:
return None
values = [(i, str(inst[var])) for i, inst in enumerate(self.data)
if not inst[var].is_special()]
return [Item(i, smiles, *self._parse_smiles(smiles))
for i, smiles in values]
def _parse_smiles(self, smiles):
try:
return (OK, molecule_from_smiles(smiles))
except Exception:
return (ParseError, None)
def updateitems(self):
if self.showFragments and self.fragmentSmiles:
values = [(None, frag) for frag in self.fragmentSmiles[1:]]
items = [Item(i, smiles, *self._parse_smiles(smiles))
for i, smiles in values]
else:
smilesvar = self.smiles_var_model[self.smiles_var]
items = self._items_from_var(smilesvar)
self._items = items
self.setupgrid()
def setupgrid(self):
self.cleargrid()
layout = self.grid
widgets = []
for item in self._items:
thumb = ThumbnailWidget(self.grid)
thumb.setImageSize(self.imageSize, self.imageSize)
if item.index is not None:
text = self._title_text(item.index)
else:
text = ""
thumb.label.setText(text)
widgets.append(thumb)
layout.appendWidget(thumb)
self._widgets = widgets
self.infoLabel.setText("Chemicals %i" % len(self._items))
self._update()
def __update_items(self, items, widgets, pattern=None):
for i, item, widget in zip(range(len(items)), items, widgets):
if item.status != ParseError:
if pattern is not None:
emb = substructure_embedding(item.molecule, pattern)
emb = reduce(list.__iadd__, emb, [])
svg = molecule_to_svg_with_substructure(item.molecule, emb)
else:
svg = molecule_to_svg(item.molecule)
else:
svg = ""
widget.setData(svg)
widget.setEnabled(True)
yield i * 100.0 / len(items)
def _update(self):
if self.showFragments and self.fragmentSmiles:
loop = self.__update_items(self._items, self._widgets)
elif self.colorFragments and self.selectedFragment:
pattern = pybel.Smarts(self.selectedFragment)
loop = self.__update_items(self._items, self._widgets, pattern)
else:
loop = self.__update_items(self._items, self._widgets)
self.__schedule(loop)
def __schedule(self, coroutine):
if self.__loop is not None:
self.progressBarFinished()
self.__loop.close()
self.__loop = None
self.__loop = coroutine
self.progressBarInit()
QTimer.singleShot(0, self.__loop_update)
@Slot()
def __loop_update(self):
if self.__loop is None:
return
try:
progress = next(self.__loop)
except StopIteration:
self.__loop = None
self.progressBarFinished()
else:
self.progressBarSet(progress)
QTimer.singleShot(0, self.__loop_update)
def _title_selection_changed(self):
self._update_titles()
def _image_size_changed(self):
for widget in self._widgets:
widget.setImageSize(self.imageSize, self.imageSize)
self.grid.layout().invalidate()
def select_marked(self):
if not pybel:
return
if not self.showFragments:
pattern = pybel.Smarts(self.selectedFragment)
for item, widget in zip(self._items, self._widgets):
if item.status != ParseError:
emb = substructure_embedding(item.molecule, pattern)
widget.setSelected(bool(emb))
else:
widget.setSelected(False)
if self.commitOnChange:
self.commit()
def _on_selection_changed(self):
if self.commitOnChange:
self.commit()
def commit(self):
if self.showFragments:
svar = self.smiles_var_model[self.smiles_var]
items = self._items_from_var(svar)
frags = [item for item, w in zip(self._items, self._widgets)
if w.selected]
patterns = [pybel.Smarts(item.smiles) for item in frags]
def test(molecule, patterns):
return any(bool(substructure_embedding(molecule, patt))
for patt in patterns)
matched = filter(
lambda item: item.status != ParseError and
test(item.molecule, patterns),
items
)
instances = [self.data[item.index] for item in matched]
if instances:
table = Orange.data.Table(instances)
self.send("Selected Molecules", table)
else:
self.send("Selected Molecules", None)
else:
items = [item for item, w in zip(self._items, self._widgets)
if w.selected]
instances = [self.data[item.index] for item in items]
if instances:
table = Orange.data.Table(instances)
self.send("Selected Molecules", table)
else:
self.send("Selected Molecules", None)
def onDeleteWidget(self):
OWWidget.onDeleteWidget(self)
if self.__loop is not None:
self.__loop.close()
self.__loop = None
class MiniCalculation(QDialog):
AppName = u"迷你计算器"
def __init__(self, parent=None):
super(MiniCalculation, self).__init__(parent)
self.btnHelpState = False
self.setWindowTitle(MiniCalculation.AppName)
self.txtBrower = QTextBrowser()
self.txtLine = QLineEdit()
self.txtLine.setPlaceholderText(u"请输入表达式，按回车结束...")
self.btnCal = QPushButton(u"计算")
self.btnClear = QPushButton(u"清空")
self.btnHelp = QPushButton(u"特殊函数表>>")
self.btnHelp.setCheckable(True)
self.btnHelp.setChecked(True)
mathList = [s for s in dir(math) if not s.startswith("__")]
self.listWidget = QListWidget()
self.listWidget.addItems(mathList)
for i in range(len(mathList)):
item = self.listWidget.item(i)
strFun = item.text() + '.__doc__'
item.setToolTip(eval(str(strFun)))
self.listWidget.setMaximumWidth(100)
midLay = QHBoxLayout()
midLay.addWidget(self.btnCal)
midLay.addWidget(self.btnClear)
midLay.addStretch()
midLay.addWidget(self.btnHelp)
bottomLay = QHBoxLayout()
bottomLay.addWidget(self.txtBrower)
bottomLay.addWidget(self.listWidget)
lay = QVBoxLayout()
lay.addWidget(self.txtLine)
lay.addItem(midLay)
lay.addItem(bottomLay)
self.resize(450, 300)
self.setLayout(lay)
self.updateUI()
self.btnCal.clicked.connect(self.btnCalClicked)
self.btnClear.clicked.connect(self.txtLine.clear)
self.btnClear.clicked.connect(self.txtBrower.clear)
self.btnHelp.clicked.connect(self.updateUI)
self.listWidget.itemDoubleClicked.connect(self.listItemDoubleClicked)
def updateUI(self):
state = not self.btnHelp.isChecked()
self.listWidget.setHidden(state)
text = u"特殊函数表>>" if state else u"特殊函数表<<"
self.btnHelp.setText(text)
def btnCalClicked(self):
try:
txt = str(self.txtLine.text())
self.txtBrower.append("%s = <b>%s</b>" % (txt, eval(txt)))
except UnicodeEncodeError:
QMessageBox.warning(self,u"QData -- 迷你计算机",
u"表达式中存在中文或全角字符\n",
QMessageBox.Ok)
except:
self.txtBrower.append("<font color=red>%s <b>is invalid</b>" % txt)
def listItemDoubleClicked(self):
item = self.listWidget.currentItem()
self.txtLine.insert(item.text())
self.txtLine.setFocus()
class SolverGenerator(QWidget):
def __init__(self):
super().__init__()
self._init_info_base()
self._init_ui()
def _init_info_base(self):
f = open('base')
lines = [line for line in f.readlines() if line.split()]
count = int(lines[0])
self._names = {}
for line in lines[1:1 + count]:
line = line.split(' ', 1)
self._names[line[1].rstrip()] = line[0]
model = [Formula(info=line1, code=line2) for line1, line2 in
zip(lines[1 + count::2], lines[2 + count::2])]
self._info_base = InfoBase(model)
def _init_ui(self):
main = QVBoxLayout(self)
up_label = QLabel('Входные параметры:')
up_label.setAlignment(Qt.AlignCenter)
main.addWidget(up_label)
up = QHBoxLayout(self)
self.up_left = QListWidget(self)
self.up_left.addItems(list(self._names.keys()))
self.up_left.sortItems()
up.addWidget(self.up_left)
up_buttons = QVBoxLayout(self)
up_to_right = QPushButton('>')
self.connect(up_to_right, SIGNAL('pressed()'), self._up_to_right)
up_buttons.addWidget(up_to_right)
up_to_left = QPushButton('<')
self.connect(up_to_left, SIGNAL('pressed()'), self._up_to_left)
up_buttons.addWidget(up_to_left)
up_buttons.setAlignment(Qt.AlignCenter)
up.addLayout(up_buttons)
self.up_right = QListWidget(self)
up.addWidget(self.up_right)
self.up_right.sortItems()
main.addLayout(up)
down_label = QLabel('Выходные параметры:')
down_label.setAlignment(Qt.AlignCenter)
main.addWidget(down_label)
down = QHBoxLayout(self)
self.down_left = QListWidget(self)
self.down_left.addItems(list(self._names.keys()))
self.down_left.sortItems()
down.addWidget(self.down_left)
down_buttons = QVBoxLayout(self)
down_to_right = QPushButton('>')
self.connect(down_to_right, SIGNAL('pressed()'), self._down_to_right)
down_buttons.addWidget(down_to_right)
down_to_left = QPushButton('<')
self.connect(down_to_left, SIGNAL('pressed()'), self._down_to_left)
down_buttons.addWidget(down_to_left)
down_buttons.setAlignment(Qt.AlignCenter)
down.addLayout(down_buttons)
self.down_right = QListWidget(self)
down.addWidget(self.down_right)
self.down_right.sortItems()
main.addLayout(down)
solve = QPushButton('Решить')
self.connect(solve, SIGNAL('pressed()'), self._solve)
main.addWidget(solve)
self.setLayout(main)
self.setWindowTitle('SolverGenerator')
self.resize(600, 600)
self._center()
self.show()
def _solve(self):
input_definition = [self.up_right.item(i).text() for i in
range(self.up_right.count())]
input_params = [self._names[item] for item in input_definition]
output_definition = [self.down_right.item(i).text() for i in
range(self.down_right.count())]
output_params = [self._names[item] for item in output_definition]
algorithm = self._info_base.get_algorithm(input_params, output_params)
if algorithm:
self._generate_code(input_definition, input_params,
output_definition, output_params, algorithm)
else:
QMessageBox().warning(self, 'Решения нет',
'Для выбранных данных решения нет')
def _up_to_right(self):
item = self.up_left.takeItem(self.up_left.currentRow())
self.up_right.addItem(item)
self.up_right.sortItems()
def _up_to_left(self):
item = self.up_right.takeItem(self.up_right.currentRow())
self.up_left.addItem(item)
self.up_left.sortItems()
def _down_to_right(self):
item = self.down_left.takeItem(self.down_left.currentRow())
self.down_right.addItem(item)
self.down_right.sortItems()
def _down_to_left(self):
item = self.down_right.takeItem(self.down_right.currentRow())
self.down_left.addItem(item)
self.down_left.sortItems()
def _center(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
@staticmethod
def _generate_code(input_definition, input_params, output_definition,
output_params, algorithm):
code = []
if any('math' in formula.code for formula in algorithm):
code.append('import math')
for name, definition in zip(input_params, input_definition):
code.append(
'{0} = float(input("Введите {0} ({1}): "))'.format(name,
definition.lower()))
for formula in algorithm:
code.append(formula.code)
for name, definition in zip(output_params, output_definition):
code.append('print("{0} = %f" % {1})'.format(definition, name))
code.append('input("Нажмите Enter для завершения.")')
code.append('')
code = '\n'.join(code)
file = open('program.py', 'w')
file.write(code)
file.close()
xterm = sh.Command('xterm')
xterm('-e', 'python3 program.py')
class ProfilesLoader(QDialog):
def __init__(self,
load_func,
create_func,
save_func,
profiles,
parent=None):
QDialog.__init__(self, parent, Qt.Dialog)
self.setWindowTitle(self.tr("Profile Manager"))
self.setMinimumWidth(400)
self._profiles = profiles
self.load_function = load_func
self.create_function = create_func
self.save_function = save_func
self.ide = parent
vbox = QVBoxLayout(self)
vbox.addWidget(
QLabel(
self.tr("Save your opened files and projects "
"into a profile and change really quick\n"
"between projects and files sessions.\n"
"This allows you to save your working environment, "
"keep working in another\nproject and then go back "
"exactly where you left.")))
self.profileList = QListWidget()
self.profileList.addItems([key for key in profiles])
self.profileList.setCurrentRow(0)
self.contentList = QListWidget()
self.btnDelete = QPushButton(self.tr("Delete Profile"))
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnUpdate = QPushButton(self.tr("Update Profile"))
self.btnUpdate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnCreate = QPushButton(self.tr("Create New Profile"))
self.btnCreate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(self.tr("Open Profile"))
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnUpdate)
hbox.addWidget(self.btnCreate)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.profileList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.profileList, SIGNAL("itemSelectionChanged()"),
self.load_profile_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_profile)
self.connect(self.btnUpdate, SIGNAL("clicked()"), self.save_profile)
self.connect(self.btnCreate, SIGNAL("clicked()"), self.create_profile)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_profile)
def load_profile_content(self):
item = self.profileList.currentItem()
self.contentList.clear()
if item is not None:
key = item.text()
files = [self.tr('Files:')] + \
[file[0] for file in self._profiles[key][0]]
projects = [self.tr('Projects:')] + self._profiles[key][1]
content = files + projects
self.contentList.addItems(content)
def create_profile(self):
profileName = self.create_function()
self.ide.Profile = profileName
self.close()
def save_profile(self):
if self.profileList.currentItem():
profileName = self.profileList.currentItem().text()
self.save_function(profileName)
self.ide.show_status_message(
self.tr("Profile %s Updated!" % profileName))
self.load_profile_content()
def open_profile(self):
if self.profileList.currentItem():
key = self.profileList.currentItem().text()
self.load_function(key)
self.ide.Profile = key
self.close()
def delete_profile(self):
if self.profileList.currentItem():
key = self.profileList.currentItem().text()
self._profiles.pop(key)
self.profileList.takeItem(self.profileList.currentRow())
self.contentList.clear()
class ViewerWnd(QMainWindow):
def __init__(self, layer, prop):
QMainWindow.__init__(self)
self.setWindowTitle('PostGIS Viewer - %s' % (layer.name()))
self.canvas = QgsMapCanvas()
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(True)
tmp = QgsMapLayerRegistry.instance()
tmp.addMapLayer(layer)
self.canvas.setExtent(layer.extent())
self.canvas.setLayerSet( [ QgsMapCanvasLayer(layer) ] )
self.setCentralWidget(self.canvas)
actionZoomIn = QAction(QString("Zoom in"), self)
actionZoomOut = QAction(QString("Zoom out"), self)
actionPan = QAction(QString("Pan"), self)
actionZoomIn.setCheckable(True)
actionZoomOut.setCheckable(True)
actionPan.setCheckable(True)
self.connect(actionZoomIn, SIGNAL("triggered()"), self.zoomIn)
self.connect(actionZoomOut, SIGNAL("triggered()"), self.zoomOut)
self.connect(actionPan, SIGNAL("triggered()"), self.pan)
self.toolbar = self.addToolBar("Canvas actions")
self.toolbar.addAction(actionZoomIn)
self.toolbar.addAction(actionZoomOut)
self.toolbar.addAction(actionPan)
# create the map tools
self.toolPan = QgsMapToolPan(self.canvas)
self.toolPan.setAction(actionPan)
self.toolZoomIn = QgsMapToolZoom(self.canvas, False) # false = in
self.toolZoomIn.setAction(actionZoomIn)
self.toolZoomOut = QgsMapToolZoom(self.canvas, True) # true = out
self.toolZoomOut.setAction(actionZoomOut)
self.pan()
dock_layer_prop = QDockWidget(self.tr('Layer Properties'), self)
dock_layer_prop.setAllowedAreas(Qt.BottomDockWidgetArea)
self.layer_prop = QListWidget(dock_layer_prop)
self.layer_prop.addItems(QStringList()
<< "Layer: %s" % layer.name()
<< "Source: %s" % layer.source()
<< "Geometry: %s" % prop['geom_type']
<< "Extent: %s" % layer.extent().toString()
<< "PostGIS: %s" % prop['postgis_version']
)
dock_layer_prop.setWidget(self.layer_prop)
self.addDockWidget(Qt.BottomDockWidgetArea, dock_layer_prop)
def zoomIn(self):
self.canvas.setMapTool(self.toolZoomIn)
def zoomOut(self):
self.canvas.setMapTool(self.toolZoomOut)
def pan(self):
self.canvas.setMapTool(self.toolPan)
class SessionsManager(QDialog):
"""Session Manager, to load different configurations of ninja."""
def __init__(self, parent=None):
super(SessionsManager, self).__init__(parent, Qt.Dialog)
self._ide = parent
self.setWindowTitle(translations.TR_SESSIONS_TITLE)
self.setMinimumWidth(400)
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel(translations.TR_SESSIONS_DIALOG_BODY))
self.sessionList = QListWidget()
self.sessionList.addItems([key for key in settings.SESSIONS])
self.sessionList.setCurrentRow(0)
self.contentList = QListWidget()
self.btnDelete = QPushButton(translations.TR_SESSIONS_BTN_DELETE)
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnUpdate = QPushButton(translations.TR_SESSIONS_BTN_UPDATE)
self.btnUpdate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnCreate = QPushButton(translations.TR_SESSIONS_BTN_CREATE)
self.btnCreate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(translations.TR_SESSIONS_BTN_ACTIVATE)
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnUpdate)
hbox.addWidget(self.btnCreate)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.sessionList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.sessionList, SIGNAL("itemSelectionChanged()"),
self.load_session_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_session)
self.connect(self.btnUpdate, SIGNAL("clicked()"), self.save_session)
self.connect(self.btnCreate, SIGNAL("clicked()"), self.create_session)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_session)
self.load_session_content()
def load_session_content(self):
"""Load the selected session, replacing the current session."""
item = self.sessionList.currentItem()
self.contentList.clear()
if item is not None:
key = item.text()
files = [self.tr('Files:')] + \
[file[0] for file in settings.SESSIONS[key][0]]
projects = [self.tr('Projects:')] + settings.SESSIONS[key][1]
content = files + projects
self.contentList.addItems(content)
def create_session(self):
"""Create a new Session."""
sessionInfo = QInputDialog.getText(
None, translations.TR_SESSIONS_CREATE_TITLE,
translations.TR_SESSIONS_CREATE_BODY)
if sessionInfo[1]:
sessionName = sessionInfo[0]
if not sessionName or sessionName in settings.SESSIONS:
QMessageBox.information(self,
translations.TR_SESSIONS_MESSAGE_TITLE,
translations.TR_SESSIONS_MESSAGE_BODY)
return
SessionsManager.save_session_data(sessionName, self._ide)
self._ide.Session = sessionName
self.close()
@classmethod
def save_session_data(cls, sessionName, ide):
"""Save the updates from a session."""
openedFiles = ide.filesystem.get_files()
files_info = []
for path in openedFiles:
editable = ide.get_or_create_editable(path)
if editable.is_dirty:
stat_value = 0
else:
stat_value = os.stat(path).st_mtime
files_info.append(
[path, editable.editor.get_cursor_position(), stat_value])
projects_obj = ide.filesystem.get_projects()
projects = [projects_obj[proj].path for proj in projects_obj]
settings.SESSIONS[sessionName] = [files_info, projects]
qsettings = ide.data_settings()
qsettings.setValue('ide/sessions', settings.SESSIONS)
def save_session(self):
if self.sessionList.currentItem():
sessionName = self.sessionList.currentItem().text()
SessionsManager.save_session_data(sessionName, self._ide)
self._ide.show_message(
translations.TR_SESSIONS_UPDATED_NOTIF %
{'session': sessionName}, 2000)
self.load_session_content()
def open_session(self):
if self.sessionList.currentItem():
key = self.sessionList.currentItem().text()
self._load_session_data(key)
self._ide.Session = key
self.close()
def delete_session(self):
if self.sessionList.currentItem():
key = self.sessionList.currentItem().text()
settings.SESSIONS.pop(key)
self.sessionList.takeItem(self.sessionList.currentRow())
self.contentList.clear()
qsettings = self._ide.data_settings()
qsettings.setValue('ide/sessions', settings.SESSIONS)
def _load_session_data(self, key):
"""Activate the selected session, closing the current files/projects"""
main_container = self._ide.get_service('main_container')
projects_explorer = self._ide.get_service('projects_explorer')
if projects_explorer and main_container:
projects_explorer.close_opened_projects()
for fileData in settings.SESSIONS[key][0]:
path, line, stat_value = fileData
if file_manager.file_exists(path):
mtime = os.stat(path).st_mtime
ignore_checkers = (mtime == stat_value)
main_container.open_file(path,
line,
ignore_checkers=ignore_checkers)
if projects_explorer:
projects_explorer.load_session_projects(
settings.SESSIONS[key][1])
class OWMoleculeVisualizer(OWWidget):
settingsList = ["colorFragmets", "showFragments"]
contextHandlers = {
"":
DomainContextHandler("", [
ContextField("selected_title_indices"),
ContextField("moleculeTitleAttributeList",
(DomainContextHandler.List +
DomainContextHandler.SelectedRequired +
DomainContextHandler.IncludeMetaAttributes),
selected="selectedMoleculeTitleAttrs"),
ContextField(
"smiles_var", DomainContextHandler.Required +
DomainContextHandler.IncludeMetaAttributes)
],
maxAttributesToPickle=1000)
}
def __init__(self,
parent=None,
signalManager=None,
title="Molecule visualizer"):
super(OWMoleculeVisualizer, self).__init__(parent, signalManager,
title)
self.colorFragments = 1
self.showFragments = 0
self.selectedFragment = ""
self.moleculeSmiles = []
self.fragmentSmiles = []
self.defFragmentSmiles = []
self.smiles_var = 0
self.moleculeTitleAttr = 0
self.moleculeTitleAttributeList = []
self.selectedMoleculeTitleAttrs = []
self.fragmentSmilesAttr = 0
self.imageSize = 200
self.numColumns = 4
self.commitOnChange = 0
## GUI
box = OWGUI.widgetBox(self.controlArea, "Info", addSpace=True)
self.infoLabel = OWGUI.label(box, self, "Chemicals:")
box = OWGUI.radioButtonsInBox(self.controlArea,
self,
"showFragments",
["Show molecules", "Show fragments"],
"Show",
callback=self.updateitems)
self.showFragmentsRadioButton = box.buttons[-1]
self.markFragmentsCheckBox = OWGUI.checkBox(box,
self,
"colorFragments",
"Mark fragments",
callback=self._update)
box.setSizePolicy(QSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Maximum))
OWGUI.separator(self.controlArea)
self.moleculeSmilesCombo = OWGUI.comboBox(self.controlArea,
self,
"smiles_var",
"Molecule SMILES Attribute",
callback=self.updateitems)
self.moleculeSmilesCombo.box.setSizePolicy(
QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum))
self.smiles_var_model = VariableListModel(parent=self)
self.moleculeSmilesCombo.setModel(self.smiles_var_model)
OWGUI.separator(self.controlArea)
box = OWGUI.widgetBox(self.controlArea,
"Molecule Title Attributes",
addSpace=True)
self.title_var_view = QListView(
selectionMode=QListView.ExtendedSelection)
self.title_var_model = VariableListModel(parent=self)
self.title_var_view.setModel(self.title_var_model)
self.title_var_view.selectionModel().selectionChanged.connect(
self._title_selection_changed)
box.layout().addWidget(self.title_var_view)
OWGUI.separator(self.controlArea)
self.fragmentSmilesCombo = OWGUI.comboBox(
self.controlArea,
self,
"fragmentSmilesAttr",
"Fragment SMILES Attribute",
callback=self.updateFragmentsListBox)
self.fragmentSmilesCombo.setModel(VariableListModel(parent=self))
self.fragmentSmilesCombo.box.setSizePolicy(
QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum))
OWGUI.separator(self.controlArea)
box = OWGUI.spin(self.controlArea,
self,
"imageSize",
50,
500,
10,
box="Image Size",
callback=self._image_size_changed)
box.setSizePolicy(QSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Maximum))
OWGUI.separator(self.controlArea)
box = OWGUI.widgetBox(self.controlArea, "Selection", addSpace=True)
OWGUI.checkBox(box, self, "commitOnChange", "Commit on change")
self.selectMarkedMoleculesButton = OWGUI.button(
box, self, "Select &matched molecules", self.select_marked)
OWGUI.button(box, self, "&Commit", callback=self.commit, default=True)
OWGUI.separator(self.controlArea)
OWGUI.rubber(self.controlArea)
spliter = QSplitter(Qt.Vertical)
self.scrollArea = ScrollArea(spliter)
self.grid = GridWidget()
self.grid.selectionChanged.connect(self._on_selection_changed)
self.scrollArea.setWidget(self.grid)
self.scrollArea.setWidgetResizable(True)
self.mainArea.layout().addWidget(spliter)
if pybel:
self.listBox = QListWidget(spliter)
else:
self.listBox = QListWidget(None)
self.listBox.setHidden(True)
self.listBox.itemClicked.connect(self.fragmentSelection)
self.fragmentSmilesCombo.box.setDisabled(not pybel)
self.data = None
self.data_subset = []
self.fragment_data = None
self.resize(800, 600)
self.listBox.setMaximumHeight(150)
self.fragmentSmilesCombo.setDisabled(True)
self.selectMarkedMoleculesButton.setDisabled(True)
self.markFragmentsCheckBox.setDisabled(True)
self.showFragmentsRadioButton.setDisabled(True)
self.loadSettings()
if not pybel:
self.showFragments = 0
self.warning(
10, "Pybel module not installed. To view molecule fragments\n"
"please install openbabel python extension.")
self.__loop = None
def setMoleculeTable(self, data):
self.closeContext()
self.clear()
self.data = data
if data is not None:
all_vars = data.domain.variables + data.domain.get_metas().values()
text_vars = filter(
lambda v: isinstance(v, (Orange.feature.Discrete, Orange.
feature.String)), all_vars)
var_scored = score_smiles_variables(data, text_vars)
self.smiles_var_model[:] = [var for var, _ in var_scored]
self.smiles_var = max(range(len(var_scored)),
key=lambda i: var_scored[i][1])
self.title_var_model[:] = all_vars
self.setFragmentSmilesCombo()
self.updateFragmentsListBox()
if self.data_subset:
try:
self.data_subset = self.data_subset.select(
self.data.domain)
except Exception:
self.data_subset = []
self.openContext("", data)
else:
self.defFragmentSmiles = []
if not self.fragmentSmilesAttr:
self.listBox.clear()
self.openContext("", data)
self.send("Selected Molecules", None)
def setMoleculeSubset(self, data):
self.data_subset = data
try:
self.data_subset = self.data_subset.select(self.data.domain)
except Exception:
self.data_subset = []
def setFragmentTable(self, data):
self.fragment_data = data
if data is not None:
self.setFragmentSmilesCombo()
self.updateFragmentsListBox()
self.selectedFragment = ""
else:
self.setFragmentSmilesCombo()
self.updateFragmentsListBox()
self.fragmentSmilesCombo.setEnabled(data is not None)
def handleNewSignals(self):
self.updateitems()
def clear(self):
self.smiles_var_model[:] = []
self.title_var_model[:] = []
self.fragmentSmilesCombo.clear()
self.grid.clear()
self._widgets = []
self._items = []
if self.__loop is not None:
self.__loop.close()
self.__loop = None
def cleargrid(self):
self.grid.clear()
self._widgets = []
def _update_titles(self):
if self.data is None:
return
title_vars = [
self.title_var_model[ind.row()]
for ind in self.title_var_view.selectedIndexes()
]
for item, widget in zip(self._items, self._widgets):
inst = self.data[item.index]
text = " / ".join(map(str, (inst[var] for var in title_vars)))
widget.label.setText(text)
def setFragmentSmilesCombo(self):
if self.fragment_data:
candidates = score_smiles_variables(self.fragment_data)
else:
candidates = []
self.fragmentSmilesCombo.model()[:] = [v for v, _ in candidates]
if self.fragmentSmilesAttr > len(candidates):
self.fragmentSmilesAttr = 0
def updateFragmentsListBox(self):
if pybel is None:
return
fragvars = self.fragmentSmilesCombo.model()
if 0 <= self.fragmentSmilesAttr < len(fragvars):
fvar = fragvars[self.fragmentSmilesAttr]
else:
fvar = None
if fvar:
frags = [
str(e[fvar]) for e in self.fragment_data
if not e[fvar].is_special()
]
self.fragmentSmiles = [""] + frags
else:
self.fragmentSmiles = [""] + self.defFragmentSmiles
self.listBox.clear()
self.listBox.addItems(self.fragmentSmiles)
self.showFragmentsRadioButton.setDisabled(
len(self.fragmentSmiles) == 1)
self.markFragmentsCheckBox.setDisabled(len(self.fragmentSmiles) == 1)
self.selectMarkedMoleculesButton.setDisabled(True)
def fragmentSelection(self, item):
if pybel is None:
return
index = self.listBox.indexFromItem(item).row()
if index == -1:
index = 0
self.selectedFragment = self.fragmentSmiles[index]
self.selectMarkedMoleculesButton.setEnabled(bool(
self.selectedFragment))
self.markFragmentsCheckBox.setEnabled(bool(self.selectedFragment))
if not self.showFragments and self.colorFragments:
self._update()
def _title_text(self, index):
title_vars = [
self.title_var_model[ind.row()]
for ind in self.title_var_view.selectedIndexes()
]
inst = self.data[index]
return " / ".join(map(str, (inst[var] for var in title_vars)))
def _items_from_var(self, var):
if self.data is None:
return None
values = [(i, str(inst[var])) for i, inst in enumerate(self.data)
if not inst[var].is_special()]
return [
Item(i, smiles, *self._parse_smiles(smiles))
for i, smiles in values
]
def _parse_smiles(self, smiles):
try:
return (OK, molecule_from_smiles(smiles))
except Exception:
return (ParseError, None)
def updateitems(self):
if self.showFragments and self.fragmentSmiles:
values = [(None, frag) for frag in self.fragmentSmiles[1:]]
items = [
Item(i, smiles, *self._parse_smiles(smiles))
for i, smiles in values
]
else:
smilesvar = self.smiles_var_model[self.smiles_var]
items = self._items_from_var(smilesvar)
self._items = items
self.setupgrid()
def setupgrid(self):
self.cleargrid()
layout = self.grid
widgets = []
for item in self._items:
thumb = ThumbnailWidget(self.grid)
thumb.setImageSize(self.imageSize, self.imageSize)
if item.index is not None:
text = self._title_text(item.index)
else:
text = ""
thumb.label.setText(text)
widgets.append(thumb)
layout.appendWidget(thumb)
self._widgets = widgets
self.infoLabel.setText("Chemicals %i" % len(self._items))
self._update()
def __update_items(self, items, widgets, pattern=None):
for i, item, widget in zip(range(len(items)), items, widgets):
if item.status != ParseError:
if pattern is not None:
emb = substructure_embedding(item.molecule, pattern)
emb = reduce(list.__iadd__, emb, [])
svg = molecule_to_svg_with_substructure(item.molecule, emb)
else:
svg = molecule_to_svg(item.molecule)
else:
svg = ""
widget.setData(svg)
widget.setEnabled(True)
yield i * 100.0 / len(items)
def _update(self):
if self.showFragments and self.fragmentSmiles:
loop = self.__update_items(self._items, self._widgets)
elif self.colorFragments and self.selectedFragment:
pattern = pybel.Smarts(self.selectedFragment)
loop = self.__update_items(self._items, self._widgets, pattern)
else:
loop = self.__update_items(self._items, self._widgets)
self.__schedule(loop)
def __schedule(self, coroutine):
if self.__loop is not None:
self.progressBarFinished()
self.__loop.close()
self.__loop = None
self.__loop = coroutine
self.progressBarInit()
QTimer.singleShot(0, self.__loop_update)
@Slot()
def __loop_update(self):
if self.__loop is None:
return
try:
progress = next(self.__loop)
except StopIteration:
self.__loop = None
self.progressBarFinished()
else:
self.progressBarSet(progress)
QTimer.singleShot(0, self.__loop_update)
def _title_selection_changed(self):
self._update_titles()
def _image_size_changed(self):
for widget in self._widgets:
widget.setImageSize(self.imageSize, self.imageSize)
self.grid.layout().invalidate()
def select_marked(self):
if not pybel:
return
if not self.showFragments:
pattern = pybel.Smarts(self.selectedFragment)
for item, widget in zip(self._items, self._widgets):
if item.status != ParseError:
emb = substructure_embedding(item.molecule, pattern)
widget.setSelected(bool(emb))
else:
widget.setSelected(False)
if self.commitOnChange:
self.commit()
def _on_selection_changed(self):
if self.commitOnChange:
self.commit()
def commit(self):
if self.showFragments:
svar = self.smiles_var_model[self.smiles_var]
items = self._items_from_var(svar)
frags = [
item for item, w in zip(self._items, self._widgets)
if w.selected
]
patterns = [pybel.Smarts(item.smiles) for item in frags]
def test(molecule, patterns):
return any(
bool(substructure_embedding(molecule, patt))
for patt in patterns)
matched = filter(
lambda item: item.status != ParseError and test(
item.molecule, patterns), items)
instances = [self.data[item.index] for item in matched]
if instances:
table = Orange.data.Table(instances)
self.send("Selected Molecules", table)
else:
self.send("Selected Molecules", None)
else:
items = [
item for item, w in zip(self._items, self._widgets)
if w.selected
]
instances = [self.data[item.index] for item in items]
if instances:
table = Orange.data.Table(instances)
self.send("Selected Molecules", table)
else:
self.send("Selected Molecules", None)
def onDeleteWidget(self):
OWWidget.onDeleteWidget(self)
if self.__loop is not None:
self.__loop.close()
self.__loop = None
class SessionsManager(QDialog):
"""Session Manager, to load different configurations of ninja."""
def __init__(self, parent=None):
super(SessionsManager, self).__init__(parent, Qt.Dialog)
self._ide = parent
self.setWindowTitle(translations.TR_SESSIONS_TITLE)
self.setMinimumWidth(400)
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel(translations.TR_SESSIONS_DIALOG_BODY))
self.sessionList = QListWidget()
self.sessionList.addItems([key for key in settings.SESSIONS])
self.sessionList.setCurrentRow(0)
self.contentList = QListWidget()
self.btnDelete = QPushButton(translations.TR_SESSIONS_BTN_DELETE)
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnUpdate = QPushButton(translations.TR_SESSIONS_BTN_UPDATE)
self.btnUpdate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnCreate = QPushButton(translations.TR_SESSIONS_BTN_CREATE)
self.btnCreate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(translations.TR_SESSIONS_BTN_ACTIVATE)
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnUpdate)
hbox.addWidget(self.btnCreate)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.sessionList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.sessionList, SIGNAL("itemSelectionChanged()"), self.load_session_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_session)
self.connect(self.btnUpdate, SIGNAL("clicked()"), self.save_session)
self.connect(self.btnCreate, SIGNAL("clicked()"), self.create_session)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_session)
self.load_session_content()
def load_session_content(self):
"""Load the selected session, replacing the current session."""
item = self.sessionList.currentItem()
self.contentList.clear()
if item is not None:
key = item.text()
files = [translations.TR_FILES] + [file[0] for file in settings.SESSIONS[key][0]]
projects = [translations.TR_PROJECT] + settings.SESSIONS[key][1]
content = files + projects
self.contentList.addItems(content)
def create_session(self):
"""Create a new Session."""
sessionInfo = QInputDialog.getText(
None, translations.TR_SESSIONS_CREATE_TITLE, translations.TR_SESSIONS_CREATE_BODY
)
if sessionInfo[1]:
sessionName = sessionInfo[0]
if not sessionName or sessionName in settings.SESSIONS:
QMessageBox.information(
self, translations.TR_SESSIONS_MESSAGE_TITLE, translations.TR_SESSIONS_MESSAGE_BODY
)
return
SessionsManager.save_session_data(sessionName, self._ide)
self._ide.Session = sessionName
self.close()
@classmethod
def save_session_data(cls, sessionName, ide):
"""Save the updates from a session."""
openedFiles = ide.filesystem.get_files()
files_info = []
for path in openedFiles:
editable = ide.get_or_create_editable(path)
if editable.is_dirty:
stat_value = 0
else:
stat_value = os.stat(path).st_mtime
files_info.append([path, editable.editor.getCursorPosition(), stat_value])
projects_obj = ide.filesystem.get_projects()
projects = [projects_obj[proj].path for proj in projects_obj]
settings.SESSIONS[sessionName] = [files_info, projects]
qsettings = ide.data_settings()
qsettings.setValue("ide/sessions", settings.SESSIONS)
def save_session(self):
"""Save current session"""
if self.sessionList.currentItem():
sessionName = self.sessionList.currentItem().text()
SessionsManager.save_session_data(sessionName, self._ide)
self._ide.show_message(translations.TR_SESSIONS_UPDATED_NOTIF % {"session": sessionName}, 2000)
self.load_session_content()
def open_session(self):
"""Open a saved session"""
if self.sessionList.currentItem():
key = self.sessionList.currentItem().text()
self._load_session_data(key)
self._ide.Session = key
self.close()
def delete_session(self):
"""Delete a session"""
if self.sessionList.currentItem():
key = self.sessionList.currentItem().text()
settings.SESSIONS.pop(key)
self.sessionList.takeItem(self.sessionList.currentRow())
self.contentList.clear()
qsettings = self._ide.data_settings()
qsettings.setValue("ide/sessions", settings.SESSIONS)
def _load_session_data(self, key):
"""Activate the selected session, closing the current files/projects"""
main_container = self._ide.get_service("main_container")
projects_explorer = self._ide.get_service("projects_explorer")
if projects_explorer and main_container:
projects_explorer.close_opened_projects()
for fileData in settings.SESSIONS[key][0]:
path, line, stat_value = fileData
if file_manager.file_exists(path):
mtime = os.stat(path).st_mtime
ignore_checkers = mtime == stat_value
main_container.open_file(path, line, ignore_checkers=ignore_checkers)
if projects_explorer:
projects_explorer.load_session_projects(settings.SESSIONS[key][1])
class GitStatus(QDialog):
def __init__(self, plugin, git, path):
QDialog.__init__(self)
self.git = git
self.plugin = plugin
self.setWindowTitle('Git status')
layout = QGridLayout(self)
branches = self.git.branch(unicode(path))
self.s_branches = QListWidget()
if len(branches) > 0:
self.s_branches.addItems(branches[1:])
self.actual_branch = QLabel("<h2>{0}</h2>".format(branches[0]))
else:
self.actual_branch = QLabel()
branch = QLabel("<h2>Branches</h2>")
change_branch = QPushButton("Change to")
merge_branches = QPushButton("Merge branch")
H = QHBoxLayout()
delete_branch = QPushButton("Delete branch")
add_branch = QPushButton("Add branch")
H.addWidget(add_branch)
H.addWidget(delete_branch)
self.lists = []
no_staged = QLabel("<h2>No staged</h2>")
untracked_files = QLabel("Untracked files")
self.untracked_files = QListWidget()
self.lists.append(self.untracked_files)
modified_files = QLabel("Modified files")
self.modified_files = QListWidget()
self.lists.append(self.modified_files)
deleted_files = QLabel("Deleted files")
self.deleted_files = QListWidget()
self.lists.append(self.deleted_files)
staged = QLabel("<h2>Staged</h2>")
added_files = QLabel("Added files")
self.added_files = QListWidget()
self.lists.append(self.added_files)
s_modified_files = QLabel("Modified files")
self.s_modified_files = QListWidget()
self.lists.append(self.s_modified_files)
s_deleted_files = QLabel("Deleted files")
self.s_deleted_files = QListWidget()
self.lists.append(self.s_deleted_files)
layout.addWidget(self.actual_branch, 0, 0, Qt.AlignHCenter)
layout.addWidget(change_branch, 1, 0)
layout.addWidget(merge_branches, 2, 0)
layout.addWidget(no_staged, 3, 0)
layout.addWidget(untracked_files, 4, 0)
layout.addWidget(self.untracked_files, 5, 0)
layout.addWidget(modified_files, 6, 0)
layout.addWidget(self.modified_files, 7, 0)
layout.addWidget(deleted_files, 8, 0)
layout.addWidget(self.deleted_files, 9, 0)
layout.addWidget(branch, 0, 1)
layout.addWidget(self.s_branches, 1, 1)
layout.addLayout(H, 2, 1)
layout.addWidget(staged, 3, 1)
layout.addWidget(added_files, 4, 1)
layout.addWidget(self.added_files, 5, 1)
layout.addWidget(s_modified_files, 6, 1)
layout.addWidget(self.s_modified_files, 7, 1)
layout.addWidget(s_deleted_files, 8, 1)
layout.addWidget(self.s_deleted_files, 9, 1)
self.fill(self.git.no_staged["?"], self.untracked_files)
self.fill(self.git.no_staged["M"], self.modified_files)
self.fill(self.git.no_staged["D"], self.deleted_files)
self.fill(self.git.staged["A"], self.added_files)
self.fill(self.git.staged["M"], self.s_modified_files)
self.fill(self.git.staged["D"], self.s_deleted_files)
self.staged_b = QPushButton('Stage files', self)
self.unstage_b = QPushButton("Unstage files", self)
self.commit_b = QPushButton('Commit files', self)
self.uncommit_b = QPushButton("Uncommit files", self)
layout.addWidget(self.staged_b, 10, 0)
layout.addWidget(self.unstage_b, 11, 0)
layout.addWidget(self.commit_b, 10, 1)
layout.addWidget(self.uncommit_b, 11, 1)
self.setLayout(layout)
self.connect(self.staged_b, SIGNAL('clicked()'), self.add)
self.connect(self.unstage_b, SIGNAL('clicked()'), self.unstage)
self.connect(self.commit_b, SIGNAL('clicked()'), self.commit)
self.connect(self.uncommit_b, SIGNAL('clicked()'), self.uncommit)
self.connect(change_branch, SIGNAL("clicked()"), self.change_branch)
self.connect(add_branch, SIGNAL("clicked()"), self.add_branch)
self.connect(delete_branch, SIGNAL("clicked()"), self.delete_branch)
self.connect(merge_branches, SIGNAL("clicked()"), self.merge_branches)
def fill(self, a_list, widget_list):
for x in a_list:
item = QListWidgetItem()
widget_list.addItem(item)
check_box = QCheckBox(x)
widget_list.setItemWidget(item, check_box)
def add(self):
path = self.plugin.editor.get_project_owner()
for pos in reversed(xrange(self.untracked_files.count())):
item = self.untracked_files.item(pos)
widget = self.untracked_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.add(path, text)
self.untracked_files.removeItemWidget(item)
self.untracked_files.takeItem(pos)
item = QListWidgetItem()
self.added_files.addItem(item)
check_box = QCheckBox(text)
self.added_files.setItemWidget(item, check_box)
for pos in reversed(xrange(self.modified_files.count())):
item = self.modified_files.item(pos)
widget = self.modified_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.add(path, widget.text())
self.modified_files.removeItemWidget(item)
self.modified_files.takeItem(pos)
item = QListWidgetItem()
self.s_modified_files.addItem(item)
check_box = QCheckBox(text)
self.s_modified_files.setItemWidget(item, check_box)
for pos in reversed(xrange(self.deleted_files.count())):
item = self.deleted_files.item(pos)
widget = self.deleted_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.add(path, widget.text())
self.deleted_files.removeItemWidget(item)
self.deleted_files.takeItem(pos)
item = QListWidgetItem()
self.s_deleted_files.addItem(item)
check_box = QCheckBox(text)
self.s_deleted_files.setItemWidget(item, check_box)
def unstage(self):
path = self.plugin.editor.get_project_owner()
for pos in reversed(xrange(self.untracked_files.count())):
item = self.untracked_files.item(pos)
widget = self.untracked_files.itemWidget(item)
if widget.isChecked():
self.git.unstage(path, widget.text())
self.untracked_files.removeItemWidget(item)
self.untracked_files.takeItem(pos)
for pos in reversed(xrange(self.modified_files.count())):
item = self.modified_files.item(pos)
widget = self.modified_files.itemWidget(item)
if widget.isChecked():
self.git.unstage(path, widget.text())
self.modified_files.removeItemWidget(item)
self.modified_files.takeItem(pos)
for pos in reversed(xrange(self.deleted_files.count())):
item = self.deleted_files.item(pos)
widget = self.deleted_files.itemWidget(item)
if widget.isChecked():
self.git.unstage(path, widget.text())
self.deleted_files.removeItemWidget(item)
self.deleted_files.takeItem(pos)
def commit(self):
msg = QInputDialog.getText(self, "Commit message", "Commit Message:")
if msg[1] == False:
return (0)
path = self.plugin.editor.get_project_owner()
for pos in reversed(xrange(self.added_files.count())):
item = self.added_files.item(pos)
widget = self.added_files.itemWidget(item)
if widget.isChecked():
self.git.commit(path, str(widget.text()), msg[0])
self.added_files.removeItemWidget(item)
self.added_files.takeItem(pos)
for pos in reversed(xrange(self.s_modified_files.count())):
item = self.s_modified_files.item(pos)
widget = self.s_modified_files.itemWidget(item)
if widget.isChecked():
self.git.commit(path, widget.text(), msg[0])
self.s_modified_files.removeItemWidget(item)
self.s_modified_files.takeItem(pos)
for pos in reversed(xrange(self.s_deleted_files.count())):
item = self.s_deleted_files.item(pos)
widget = self.s_deleted_files.itemWidget(item)
if widget.isChecked():
self.git.commit(path, widget.text(), msg[0])
self.s_deleted_files.takeItem(pos)
self.s_deleted_files.removeItemWidget(item)
def uncommit(self):
path = self.plugin.editor.get_project_owner()
for pos in reversed(xrange(self.added_files.count())):
item = self.added_files.item(pos)
widget = self.added_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.uncommit(path, str(widget.text()))
self.added_files.removeItemWidget(item)
self.added_files.takeItem(pos)
item = QListWidgetItem()
self.untracked_files.addItem(item)
check_box = QCheckBox(text)
self.untracked_files.setItemWidget(item, check_box)
for pos in reversed(xrange(self.s_modified_files.count())):
item = self.s_modified_files.item(pos)
widget = self.s_modified_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.uncommit(path, widget.text())
self.s_modified_files.removeItemWidget(item)
self.s_modified_files.takeItem(pos)
item = QListWidgetItem()
self.modified_files.addItem(item)
check_box = QCheckBox(text)
self.modified_files.setItemWidget(item, check_box)
for pos in reversed(xrange(self.s_deleted_files.count())):
item = self.s_deleted_files.item(pos)
widget = self.s_deleted_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.uncommit(path, widget.text())
self.s_deleted_files.removeItemWidget(item)
self.s_deleted_files.takeItem(pos)
item = QListWidgetItem()
self.deleted_files.addItem(item)
check_box = QCheckBox(text)
self.deleted_files.setItemWidget(item, check_box)
def change_branch(self):
path = self.plugin.editor.get_project_owner()
item = self.s_branches.currentItem()
if item and not self.something():
text = item.text()
self.git.change_branch(path, text)
self.s_branches.clear()
self.s_branches.addItems(self.git.branch(unicode(path))[1:])
self.actual_branch.setText("<h2>{0}<h2>".format(text))
if self.something():
v = QMessageBox()
v.setText("Error: you have unsaved changes")
v.setIcon(v.Warning)
v.exec_()
def add_branch(self):
path = self.plugin.editor.get_project_owner()
msg = QInputDialog.getText(self, "New branch", "Branch Name:")
if msg[1] == False:
return (0)
self.git.add_branch(path, msg[0])
self.s_branches.clear()
self.s_branches.addItems(self.git.branch(unicode(path))[1:])
def delete_branch(self):
path = self.plugin.editor.get_project_owner()
item = self.s_branches.currentItem()
if item:
text = str(item.text())
call = self.git.delete_branch(path, text)
if not call:
self.s_branches.clear()
self.s_branches.addItems(self.git.branch(unicode(path))[1:])
else:
m = QMessageBox()
m.setText("<h2>" + call + "</h2>")
m.setInformativeText("Force deletion?")
m.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
m.setDefaultButton(QMessageBox.Cancel)
c = m.exec_()
if c == QMessageBox.Ok:
self.git.force_delete_branch(path, text)
self.s_branches.clear()
self.s_branches.addItems(
self.git.branch(unicode(path))[1:])
def merge_branches(self):
path = self.plugin.editor.get_project_owner()
item = self.s_branches.currentItem()
if item:
text = str(item.text())
call = self.git.merge_branches(path, text)
if call:
m = QMessageBox()
m.setText(call)
m.setInformativeText("Unknown")
m.setIcon(m.Critical)
m.exec_()
def something(self):
for x in self.lists:
if x.count() > 0:
return True
return False
class ProfilesLoader(QDialog):
def __init__(self, load_func, create_func, save_func,
profiles, parent=None):
QDialog.__init__(self, parent, Qt.Dialog)
self.setWindowTitle(self.tr("Profile Manager"))
self.setMinimumWidth(400)
self._profiles = profiles
self.load_function = load_func
self.create_function = create_func
self.save_function = save_func
self.ide = parent
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel(self.tr("Save your opened files and projects "
"into a profile and change really quick\n"
"between projects and files sessions.\n"
"This allows you to save your working environment, "
"keep working in another\nproject and then go back "
"exactly where you left.")))
self.profileList = QListWidget()
self.profileList.addItems([key for key in profiles])
self.profileList.setCurrentRow(0)
self.contentList = QListWidget()
self.btnDelete = QPushButton(self.tr("Delete Profile"))
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnUpdate = QPushButton(self.tr("Update Profile"))
self.btnUpdate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnCreate = QPushButton(self.tr("Create New Profile"))
self.btnCreate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(self.tr("Open Profile"))
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnUpdate)
hbox.addWidget(self.btnCreate)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.profileList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.profileList, SIGNAL("itemSelectionChanged()"),
self.load_profile_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_profile)
self.connect(self.btnUpdate, SIGNAL("clicked()"), self.save_profile)
self.connect(self.btnCreate, SIGNAL("clicked()"), self.create_profile)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_profile)
def load_profile_content(self):
item = self.profileList.currentItem()
self.contentList.clear()
if item is not None:
key = unicode(item.text())
files = [self.tr('Files:')] + \
[file[0] for file in self._profiles[key][0]]
projects = [self.tr('Projects:')] + self._profiles[key][1]
content = files + projects
self.contentList.addItems(content)
def create_profile(self):
profileName = self.create_function()
self.ide.Profile = profileName
self.close()
def save_profile(self):
if self.profileList.currentItem():
profileName = unicode(self.profileList.currentItem().text())
self.save_function(profileName)
self.ide.show_status_message(self.tr("Profile %1 Updated!").arg(
profileName))
self.load_profile_content()
def open_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self.load_function(key)
self.ide.Profile = key
self.close()
def delete_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self._profiles.pop(key)
self.profileList.takeItem(self.profileList.currentRow())
self.contentList.clear()
class Theme(QWidget):
"""Theme widget class."""
def __init__(self, parent):
super(Theme, self).__init__()
self._preferences, vbox = parent, QVBoxLayout(self)
vbox.addWidget(QLabel(self.tr("<b>Select Theme:</b>")))
self.list_skins = QListWidget()
self.list_skins.setSelectionMode(QListWidget.SingleSelection)
vbox.addWidget(self.list_skins)
self.btn_delete = QPushButton(self.tr("Delete Theme"))
self.btn_preview = QPushButton(self.tr("Preview Theme"))
self.btn_create = QPushButton(self.tr("Create Theme"))
hbox = QHBoxLayout()
hbox.addWidget(self.btn_delete)
hbox.addSpacerItem(
QSpacerItem(10, 0, QSizePolicy.Expanding, QSizePolicy.Fixed))
hbox.addWidget(self.btn_preview)
hbox.addWidget(self.btn_create)
vbox.addLayout(hbox)
self._refresh_list()
self.connect(self.btn_preview, SIGNAL("clicked()"), self.preview_theme)
self.connect(self.btn_delete, SIGNAL("clicked()"), self.delete_theme)
self.connect(self.btn_create, SIGNAL("clicked()"), self.create_theme)
self.connect(self._preferences, SIGNAL("savePreferences()"), self.save)
def delete_theme(self):
if self.list_skins.currentRow() != 0:
file_name = ("%s.qss" % self.list_skins.currentItem().text())
qss_file = file_manager.create_path(resources.NINJA_THEME_DOWNLOAD,
file_name)
file_manager.delete_file(qss_file)
self._refresh_list()
def create_theme(self):
designer = preferences_theme_editor.ThemeEditor(self)
designer.exec_()
self._refresh_list()
def showEvent(self, event):
self._refresh_list()
super(Theme, self).showEvent(event)
def _refresh_list(self):
self.list_skins.clear()
self.list_skins.addItem("Default")
files = sorted([
file_manager.get_file_name(filename)
for filename in file_manager.get_files_from_folder(
resources.NINJA_THEME_DOWNLOAD, "qss")
])
self.list_skins.addItems(files)
if settings.NINJA_SKIN in files:
index = files.index(settings.NINJA_SKIN)
self.list_skins.setCurrentRow(index + 1)
else:
self.list_skins.setCurrentRow(0)
def save(self):
qsettings = IDE.ninja_settings()
settings.NINJA_SKIN = self.list_skins.currentItem().text()
qsettings.setValue("preferences/theme/skin", settings.NINJA_SKIN)
self.preview_theme()
def preview_theme(self):
if self.list_skins.currentRow() == 0:
qss_file = resources.NINJA_THEME
else:
file_name = ("%s.qss" % self.list_skins.currentItem().text())
qss_file = file_manager.create_path(resources.NINJA_THEME_DOWNLOAD,
file_name)
with open(qss_file) as f:
qss = f.read()
QApplication.instance().setStyleSheet(qss)
class GroupsModify(PyDialog):
"""
+--------------------------+
| Groups : Modify |
+--------------------------+
| |
| Name xxx Default |
| Coords xxx Default |
| Elements xxx Default |
| Color xxx Default |
| Add xxx Add |
| Remove xxx Remove |
| |
| Set OK Cancel |
+--------------------------+
"""
def __init__(self, data, win_parent=None, group_active='main'):
PyDialog.__init__(self, data, win_parent)
self.set_font_size(data['font_size'])
self._updated_groups = False
#self.out_data = data
#print(data)
keys = []
self.keys = [
group.name for key, group in sorted(iteritems(data))
if isinstance(key, int)
]
self.active_key = self.keys.index(group_active)
group_obj = data[self.active_key]
name = group_obj.name
self.imain = 0
self.nrows = len(self.keys)
self._default_name = group_obj.name
self._default_elements = group_obj.element_str
self.elements_pound = group_obj.elements_pound
self.table = QListWidget(parent=None)
self.table.clear()
self.table.addItems(self.keys)
self.setWindowTitle('Groups: Modify')
self.create_widgets()
self.create_layout()
self.set_connections()
self.on_set_as_main()
def create_widgets(self):
"""creates the menu objects"""
# Name
self.name = QLabel("Name:")
self.name_set = QPushButton("Set")
self.name_edit = QLineEdit(str(self._default_name).strip())
self.name_button = QPushButton("Default")
# elements
self.elements = QLabel("Element IDs:")
self.elements_edit = QLineEdit(str(self._default_elements).strip())
self.elements_button = QPushButton("Default")
# add
self.add = QLabel("Add Elements:")
self.add_edit = QElementEdit(self, str(''))
self.add_button = QPushButton("Add")
# remove
self.remove = QLabel("Remove Elements:")
self.remove_edit = QElementEdit(self, str(''))
self.remove_button = QPushButton("Remove")
# applies a unique implicitly
self.eids = parse_patran_syntax(str(self._default_elements),
pound=self.elements_pound)
# closing
#self.apply_button = QPushButton("Apply")
self.ok_button = QPushButton("Close")
#self.cancel_button = QPushButton("Cancel")
self.set_as_main_button = QPushButton("Set As Main")
self.create_group_button = QPushButton('Create New Group')
self.delete_group_button = QPushButton('Delete Group')
self.name.setEnabled(False)
self.name_set.setEnabled(False)
self.name_edit.setEnabled(False)
self.name_button.setEnabled(False)
self.elements.setEnabled(False)
self.elements_button.setEnabled(False)
self.elements_edit.setEnabled(False)
self.add.setEnabled(False)
self.add_button.setEnabled(False)
self.add_edit.setEnabled(False)
self.remove.setEnabled(False)
self.remove_button.setEnabled(False)
self.remove_edit.setEnabled(False)
self.delete_group_button.setEnabled(False)
#self.apply_button.setEnabled(False)
#self.ok_button.setEnabled(False)
def create_layout(self):
"""displays the menu objects"""
grid = QGridLayout()
grid.addWidget(self.name, 0, 0)
grid.addWidget(self.name_edit, 0, 1)
grid.addWidget(self.name_set, 0, 2)
grid.addWidget(self.name_button, 0, 3)
grid.addWidget(self.elements, 2, 0)
grid.addWidget(self.elements_edit, 2, 1)
grid.addWidget(self.elements_button, 2, 2)
grid.addWidget(self.add, 4, 0)
grid.addWidget(self.add_edit, 4, 1)
grid.addWidget(self.add_button, 4, 2)
grid.addWidget(self.remove, 5, 0)
grid.addWidget(self.remove_edit, 5, 1)
grid.addWidget(self.remove_button, 5, 2)
ok_cancel_box = QHBoxLayout()
#ok_cancel_box.addWidget(self.apply_button)
ok_cancel_box.addWidget(self.ok_button)
#ok_cancel_box.addWidget(self.cancel_button)
main_create_delete = QHBoxLayout()
main_create_delete.addWidget(self.set_as_main_button)
main_create_delete.addWidget(self.create_group_button)
main_create_delete.addWidget(self.delete_group_button)
vbox = QVBoxLayout()
vbox.addWidget(self.table)
vbox.addLayout(grid)
vbox.addLayout(main_create_delete)
vbox.addStretch()
vbox.addLayout(ok_cancel_box)
self.setLayout(vbox)
def on_set_name(self):
name = str(self.name_edit.text()).strip()
if name not in self.keys:
self.name_edit.setStyleSheet("QLineEdit{background: white;}")
group = self.out_data[self.active_key]
group.name = name
self.keys[self.active_key] = name
self.recreate_table()
elif name != self.keys[self.active_key]:
self.name_edit.setStyleSheet("QLineEdit{background: red;}")
elif name == self.keys[self.active_key]:
self.name_edit.setStyleSheet("QLineEdit{background: white;}")
def set_connections(self):
self.name_set.clicked.connect(self.on_set_name)
self.name_button.clicked.connect(self.on_default_name)
self.elements_button.clicked.connect(self.on_default_elements)
self.add_button.clicked.connect(self.on_add)
self.remove_button.clicked.connect(self.on_remove)
self.table.itemClicked.connect(self.on_update_active_key)
self.ok_button.clicked.connect(self.on_ok)
self.set_as_main_button.clicked.connect(self.on_set_as_main)
self.create_group_button.clicked.connect(self.on_create_group)
self.delete_group_button.clicked.connect(self.on_delete_group)
def on_create_group(self):
irow = self.nrows
new_key = 'Group %s' % irow
while new_key in self.keys:
irow += 1
new_key = 'Group %s' % irow
irow = self.nrows
self.keys.append(new_key)
group = Group(new_key,
element_str='',
elements_pound=self.elements_pound,
editable=True)
self.out_data[irow] = group
self.table.reset()
self.table.addItems(self.keys)
self.nrows += 1
#----------------------------------
# update internal parameters
#self.out_data = items
if self.imain > self.active_key:
self.imain += 1
#make the new group the default
self.active_key = self.nrows - 1
self.keys = [
group.name for key, group in sorted(iteritems(self.out_data))
if isinstance(key, int)
]
self.recreate_table()
def recreate_table(self):
# update gui
self.table.clear()
self.table.addItems(self.keys)
item = self.table.item(self.imain)
bold = QtGui.QFont()
bold.setBold(True)
bold.setItalic(True)
item.setFont(bold)
self.table.update()
# update key
name = self.keys[self.active_key]
self._update_active_key_by_name(name)
def on_delete_group(self):
if self.active_key == 0:
return
#self.deleted_groups.add(self.imain)
items = {}
j = 0
for i, key in sorted(iteritems(self.out_data)):
if isinstance(i, int):
continue
if i != self.active_key:
items[j] = key
j += 1
# update internal parameters
self.out_data = items
if self.imain >= self.active_key:
self.imain = max(0, self.imain - 1)
self.active_key = max(0, self.active_key - 1)
self.nrows -= 1
self.keys = [group.name for key, group in sorted(iteritems(items))]
self.recreate_table()
# update key
name = self.keys[self.active_key]
self._update_active_key_by_name(name)
def on_set_as_main(self):
bold = QtGui.QFont()
bold.setBold(True)
bold.setItalic(True)
normal = QtGui.QFont()
normal.setBold(False)
normal.setItalic(False)
obj = self.table.item(self.imain)
obj.setFont(normal)
self.imain = self.active_key
obj = self.table.item(self.imain)
obj.setFont(bold)
group = self.out_data[self.imain]
self._default_elements = group.element_str
self._default_name = group.name
self.on_update_main()
def on_update_main(self):
"""adds/removes the elements to the main actor when add/remove is pressed"""
group = self.out_data[self.imain]
if self._default_name == group.name and self.win_parent is not None:
# we're not testing the menu
self.win_parent.post_group(group)
def closeEvent(self, event):
self.out_data['close'] = True
event.accept()
def on_add(self):
eids, is_valid = self.check_patran_syntax(self.add_edit,
pound=self.elements_pound)
#adict, is_valid = self.check_patran_syntax_dict(self.add_edit)
if not is_valid:
#self.add_edit.setStyleSheet("QLineEdit{background: red;}")
return
self.eids = unique(hstack([self.eids, eids]))
#self.eids = _add(adict, ['e', 'elem', 'element'], self.eids)
#self.cids = _add(adict, ['c', 'cid', 'coord'], self.cids)
self._apply_cids_eids()
self.add_edit.clear()
self.add_edit.setStyleSheet("QLineEdit{background: white;}")
self.on_update_main()
def _apply_cids_eids(self):
#ctext = _get_collapsed_text(self.cids)
etext = _get_collapsed_text(self.eids)
#self.coords_edit.setText(str(ctext.lstrip()))
self.elements_edit.setText(str(etext.lstrip()))
self.out_data[self.active_key].element_ids = self.eids
def on_remove(self):
eids, is_valid = self.check_patran_syntax(self.remove_edit)
#adict, is_valid = self.check_patran_syntax_dict(self.remove_edit)
if not is_valid:
#self.remove_edit.setStyleSheet("QLineEdit{background: red;}")
return
#self.eids = _remove(adict, ['e', 'elem', 'element'], self.eids)
#self.cids = _remove(adict, ['c', 'cid', 'coord'], self.cids)
self.eids = setdiff1d(self.eids, eids)
self._apply_cids_eids()
self.remove_edit.clear()
self.remove_edit.setStyleSheet("QLineEdit{background: white;}")
self.on_update_main()
def on_default_name(self):
name = str(self._default_name)
self.name_edit.setText(name)
self.name_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_elements(self):
element_str = str(self._default_elements)
self.elements_edit.setText(element_str)
self.elements_edit.setStyleSheet("QLineEdit{background: white;}")
group = self.out_data[self.active_key]
group.element_str = element_str
def check_name(self, cell):
cell_value = cell.text()
try:
text = str(cell_value).strip()
except UnicodeEncodeError:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
if len(text):
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
if self._default_name != text:
if self._default_name in self.out_data:
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
def on_validate(self):
name, flag0 = self.check_name(self.name_edit)
elements, flag1 = self.check_patran_syntax(self.elements_edit,
pound=self.elements_pound)
#coords_value, flag2 = self.check_patran_syntax(self.coords_edit,
#pound=self.coords_pound)
if all([flag0, flag1]):
self._default_name = name
self._default_elements = self.eids
self.out_data['clicked_ok'] = True
self.out_data['close'] = True
return True
return False
def on_apply(self, force=False):
passed = self.on_validate()
if passed or force:
self.win_parent._apply_modify_groups(self.out_data)
return passed
def on_ok(self):
passed = self.on_apply()
if passed:
self.close()
#self.destroy()
def on_cancel(self):
self.out_data['close'] = True
self.close()
def on_update_active_key(self, index):
self.update_active_key(index)
#str(index.text())
def update_active_key(self, index):
#old_obj = self.out_data[self.imain]
name = str(index.text())
self._update_active_key_by_name(name)
def _update_active_key_by_name(self, name):
if name in self.keys:
self.active_key = self.keys.index(name)
else:
# we (hopefully) just removed a row
#self.active_key = self.keys[self.active_key]
pass
self.name_edit.setText(name)
obj = self.out_data[self.active_key]
self.eids = parse_patran_syntax(obj.element_str,
pound=obj.elements_pound)
self._default_elements = obj.element_str
self._default_name = name
self._apply_cids_eids()
self.set_as_main_button.setEnabled(True)
if name in ['main', 'anti-main']:
self.name.setEnabled(False)
self.name_set.setEnabled(False)
self.name_edit.setEnabled(False)
self.name_button.setEnabled(False)
self.elements.setEnabled(False)
self.elements_button.setEnabled(False)
self.elements_edit.setEnabled(False)
self.add.setEnabled(False)
self.add_button.setEnabled(False)
self.add_edit.setEnabled(False)
self.remove.setEnabled(False)
self.remove_button.setEnabled(False)
self.remove_edit.setEnabled(False)
self.delete_group_button.setEnabled(False)
if name == 'anti-main':
self.set_as_main_button.setEnabled(False)
#self.apply_button.setEnabled(False)
#self.ok_button.setEnabled(False)
else:
self.name.setEnabled(True)
self.name_set.setEnabled(True)
self.name_edit.setEnabled(True)
self.name_button.setEnabled(True)
self.elements.setEnabled(True)
self.elements_button.setEnabled(True)
self.add.setEnabled(True)
self.add_button.setEnabled(True)
self.add_edit.setEnabled(True)
self.remove.setEnabled(True)
self.remove_button.setEnabled(True)
self.remove_edit.setEnabled(True)
self.delete_group_button.setEnabled(True)
class Theme(QWidget):
"""Theme widget class."""
def __init__(self, parent):
super(Theme, self).__init__()
self._preferences, vbox = parent, QVBoxLayout(self)
vbox.addWidget(QLabel(self.tr("<b>Select Theme:</b>")))
self.list_skins = QListWidget()
self.list_skins.setSelectionMode(QListWidget.SingleSelection)
vbox.addWidget(self.list_skins)
self.btn_delete = QPushButton(self.tr("Delete Theme"))
self.btn_preview = QPushButton(self.tr("Preview Theme"))
self.btn_create = QPushButton(self.tr("Create Theme"))
hbox = QHBoxLayout()
hbox.addWidget(self.btn_delete)
hbox.addSpacerItem(QSpacerItem(10, 0, QSizePolicy.Expanding,
QSizePolicy.Fixed))
hbox.addWidget(self.btn_preview)
hbox.addWidget(self.btn_create)
vbox.addLayout(hbox)
self._refresh_list()
self.connect(self.btn_preview, SIGNAL("clicked()"), self.preview_theme)
self.connect(self.btn_delete, SIGNAL("clicked()"), self.delete_theme)
self.connect(self.btn_create, SIGNAL("clicked()"), self.create_theme)
self.connect(self._preferences, SIGNAL("savePreferences()"), self.save)
def delete_theme(self):
if self.list_skins.currentRow() != 0:
file_name = ("%s.qss" % self.list_skins.currentItem().text())
qss_file = file_manager.create_path(resources.NINJA_THEME_DOWNLOAD,
file_name)
file_manager.delete_file(qss_file)
self._refresh_list()
def create_theme(self):
designer = preferences_theme_editor.ThemeEditor(self)
designer.exec_()
self._refresh_list()
def showEvent(self, event):
self._refresh_list()
super(Theme, self).showEvent(event)
def _refresh_list(self):
self.list_skins.clear()
self.list_skins.addItem("Default")
files = [file_manager.get_file_name(filename) for filename in
file_manager.get_files_from_folder(
resources.NINJA_THEME_DOWNLOAD, "qss")]
files.sort()
self.list_skins.addItems(files)
if settings.NINJA_SKIN in files:
index = files.index(settings.NINJA_SKIN)
self.list_skins.setCurrentRow(index + 1)
else:
self.list_skins.setCurrentRow(0)
def save(self):
qsettings = IDE.ninja_settings()
settings.NINJA_SKIN = self.list_skins.currentItem().text()
qsettings.setValue("preferences/theme/skin", settings.NINJA_SKIN)
self.preview_theme()
def preview_theme(self):
if self.list_skins.currentRow() == 0:
qss_file = resources.NINJA_THEME
else:
file_name = ("%s.qss" % self.list_skins.currentItem().text())
qss_file = file_manager.create_path(resources.NINJA_THEME_DOWNLOAD,
file_name)
with open(qss_file) as f:
qss = f.read()
QApplication.instance().setStyleSheet(qss)
class ChainComposerDialog(QDialog):
def __init__(self, parent=None):
super(ChainComposerDialog, self).__init__(parent)
self.setWindowTitle('Composer Chain')
layout = QVBoxLayout()
mainLayout = QHBoxLayout()
selectionLayout = QVBoxLayout()
label = QLabel('Available Filters:')
selectionLayout.addWidget(label)
self.__selectionList = QListWidget()
selectionLayout.addWidget(self.__selectionList)
mainLayout.addLayout(selectionLayout)
actionsLayout = QVBoxLayout()
actionsLayout.addStretch()
addButton = QPushButton('Add>>')
addButton.clicked.connect(self.__handleAdd)
actionsLayout.addWidget(addButton)
removeButton = QPushButton('Remove')
actionsLayout.addWidget(removeButton)
removeAllButton = QPushButton('Remove All')
actionsLayout.addWidget(removeAllButton)
actionsLayout.addStretch()
mainLayout.addLayout(actionsLayout)
chainLayout = QVBoxLayout()
chainLayout.addWidget(QLabel('Chain:'))
self.__chainList = QListWidget()
chainLayout.addWidget(self.__chainList)
mainLayout.addLayout(chainLayout)
layout.addLayout(mainLayout)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.okClick)
buttonBox.rejected.connect(self.cancelClick)
layout.addWidget(buttonBox)
# buttonLayout = QHBoxLayout()
# okButton = QPushButton('OK')
# okButton.clicked.connect(self.accept)
# buttonLayout.addWidget(okButton)
# cancelButton = QPushButton('Cancel')
# cancelButton.clicked.connect(self.reject)
# buttonLayout.addWidget(cancelButton)
# layout.addLayout(buttonLayout)
self.setLayout(layout)
self.__composer = None
def okClick(self):
print "OK!"
self.accept()
def cancelClick(self):
print "Cancel"
self.reject()
def setComposer(self, composer):
self.__composer = composer
@property
def selectionList(self):
return self.__getStrings(self.__selectionList)
@selectionList.setter
def setSelectionList(self, filters):
for i in xrange(self.__selectionList.count()):
self.__selectionList.takeItem(i)
self.__selectionList.addItems(filters)
def filterAt(self, row):
return self.__selectionList.item(row).text()
def addToChain(self, filterName):
self.__chainList.addItem(filterName)
@property
def composedFilter(self):
return self.__getStrings(self.__chainList)
@staticmethod
def __getStrings(listWidget):
return tuple(listWidget.item(i) for i in
range(listWidget.count()))
def __handleAdd(self):
if self.__composer is None:
return
for item in self.__selectionList.selectedItems():
row = self.__selectionList.row(item)
self.__composer.add(row)
class ControlCocktail(QMainWindow):
def __init__(self):
super(ControlCocktail, self).__init__()
self.ui = Ui_RecipesWindow()
self.ui.setupUi(self)
self.show()
#Basic GUI done, setting up the ListWidget
self.CURR_DATABASE = "cocktails"
self.setupSignals()
self.setupList()
def searchCocktail(self, text):
print text
items = self.completeListWidget.findItems(text, Qt.MatchContains)
tempItemList = []
if len(items) > 0 and text:
for item in items:
tempItemList.append(item.text())
self.ui.cocktailListWidget.clear()
self.ui.cocktailListWidget.addItems(tempItemList)
self.ui.ingredientsLabel.setText("")
self.ui.preparationLabel.setText("")
else:
self.ui.cocktailListWidget.clear()
self.ui.cocktailListWidget.addItems(self.nameList)
def setupSignals(self):
self.ui.lineEdit.textChanged.connect(self.searchCocktail)
self.ui.cocktailListWidget.currentItemChanged.connect(
self.showTotalData)
self.ui.cocktailListWidget.itemActivated.connect(self.showTotalData)
self.ui.cocktailListWidget.itemChanged.connect(self.showTotalData)
self.ui.cocktailListWidget.itemClicked.connect(self.showTotalData)
def setupList(self):
self.newConnector = SQLiteConnector(self.CURR_DATABASE)
if not self.newConnector.connection:
QMessageBox.critical(self, "Error", u'Cannot access the Database')
else:
nameQuery = self.newConnector.getNameData(self.CURR_DATABASE)
self.nameList = []
while nameQuery.next():
self.nameList.append(nameQuery.value(0).toString())
self.ui.cocktailListWidget.addItems(self.nameList)
self.completeListWidget = QListWidget()
self.completeListWidget.addItems(self.nameList)
def showTotalData(self, listWidgetItem):
try:
currText = listWidgetItem.text()
currIngredients = self.newConnector.getIngredients(
self.CURR_DATABASE, currText)
currPreparation = self.newConnector.getPreparation(
self.CURR_DATABASE, currText)
self.ui.titleLabel.setText(currText)
self.ui.ingredientsLabel.setText(currIngredients)
self.ui.preparationLabel.setText(currPreparation)
except:
self.ui.ingredientsLabel.setText("")
self.ui.preparationLabel.setText("")
