def _layout(self):
layout = QFormLayout(self)
self.setLayout(layout)
layout.addRow(
None,
QLabel("RuneKit needs to be restarted for changes to take effect",
self),
)
tooltip_label = QLabel("Display tooltips as", self)
tooltip_field = QComboBox(self)
selected = int(
self.settings.value("settings/tooltip",
AutoNotifier.METHOD_NOTIFICATION))
selected_idx = 0
for idx, method in enumerate(AutoNotifier.availableMethods().items()):
tooltip_field.insertItem(idx, method[1])
if method[0] == selected:
selected_idx = idx
tooltip_field.setCurrentIndex(selected_idx)
tooltip_field.currentIndexChanged.connect(self.preview_tooltip)
tooltip_field.currentIndexChanged.connect(self.on_tooltip_change)
layout.addRow(tooltip_label, tooltip_field)
border_field = QCheckBox("Styled window border", self)
border_field.setDisabled(sys.platform == "darwin")
border_field.setChecked(
(self.settings.value("settings/styledBorder", "true") == "true")
and sys.platform != "darwin")
border_field.stateChanged.connect(self.on_change_styled_border)
layout.addRow(None, border_field)
def _init_load_options_tab(self, tab):
# load debug symbols
load_debug_info = QCheckBox()
load_debug_info.setText("Load debug information if available")
load_debug_info.setChecked(True)
self.option_widgets['load_debug_info'] = load_debug_info
# auto load libs
auto_load_libs = QCheckBox()
auto_load_libs.setText("Automatically load all libraries")
auto_load_libs.setChecked(False)
self.option_widgets['auto_load_libs'] = auto_load_libs
# dependencies list
dep_group = QGroupBox("Dependencies")
dep_list = QListWidget()
self.option_widgets['dep_list'] = dep_list
sublayout = QVBoxLayout()
sublayout.addWidget(dep_list)
dep_group.setLayout(sublayout)
layout = QVBoxLayout()
layout.addWidget(load_debug_info)
layout.addWidget(auto_load_libs)
layout.addWidget(dep_group)
layout.addStretch(0)
frame = QFrame(self)
frame.setLayout(layout)
tab.addTab(frame, "Loading Options")
class QW_FEMPoisson(QWidget):
updated_cadmshfem = Signal()
def __init__(self, fem: dfm2.FEM_ScalarPoisson):
super(QW_FEMPoisson, self).__init__()
self.fem = fem
self.cb1 = QCheckBox("Sync FEM to Params")
self.cb1.setChecked(True)
self.cb1.stateChanged.connect(lambda: self.btnstate(self.b1))
self.qui_sp = QW_SolveParam(self.fem)
self.qui_sp.updated_cadmshfem.connect(
lambda: self.updated_cadmshfem.emit())
####
self.vs1 = QW_FemParams(["alpha", "source"], self.fem)
self.vs1.valueChanged.connect(self.fem_param_changed)
####
self.vl = QVBoxLayout()
self.vl.addWidget(self.qui_sp, alignment=Qt.AlignLeft)
self.vl.addWidget(self.vs1, alignment=Qt.AlignLeft)
self.vl.addStretch()
self.setLayout(self.vl)
def fem_param_changed(self):
if self.qui_sp.cb1.isChecked():
self.fem.solve()
self.updated_cadmshfem.emit()
def get_day_layout(self, day_text):
day_label = QLabel(day_text)
day_label.setFixedWidth(120)
day_label.setFixedHeight(50)
day_label.setFont(self.day_font)
day_label.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
gen_day_button = QPushButton("Plan day")
gen_day_button.setFont(self.general_font)
gen_day_button.font().setBold(False)
use_day_check = QCheckBox("Use: ")
use_day_check.setLayoutDirection(QtCore.Qt.RightToLeft)
use_day_check.setChecked(True)
use_day_check.setFont(self.general_font)
day_layout = QHBoxLayout()
day_layout.addWidget(day_label)
day_layout.addWidget(use_day_check)
info_layout = QVBoxLayout()
info_layout.addLayout(day_layout)
info_layout.addWidget(gen_day_button)
day_text_edit = QTextEdit()
day_text_edit.setFont(self.general_font)
#Create, fill and return the day layout
day_layout = QHBoxLayout()
day_layout.addLayout(info_layout)
day_layout.addWidget(day_text_edit)
return day_layout
def init_underline_widget(text_item):
underline_checkbox = QCheckBox("Underline")
underline_checkbox.setChecked(text_item.font().underline())
underline_checkbox.stateChanged.connect(lambda x:
set_font_underline(x,
text_item))
return underline_checkbox
def init_strikeout_widget(text_item):
strikeout_checkbox = QCheckBox("Strikeout")
strikeout_checkbox.setChecked(text_item.font().strikeOut())
strikeout_checkbox.stateChanged.connect(lambda x:
set_font_strikeout(x,
text_item))
return strikeout_checkbox
def init_overline_widget(text_item):
overline_checkbox = QCheckBox("Overline")
overline_checkbox.setChecked(text_item.font().overline())
overline_checkbox.stateChanged.connect(lambda x:
set_font_overline(x,
text_item))
return overline_checkbox
class Integration(Page):
"""
The integration page.
"""
NAME = 'OS Integration'
def __init__(self, parent=None):
super().__init__(parent)
self._url_scheme_chk = None # type:QCheckBox
self._url_scheme_text = None # type:QLineEdit
self._init_widgets()
self._load_config()
def _init_widgets(self):
# os integration
os_integration = QGroupBox("OS integration")
self._url_scheme_chk = QCheckBox("Register angr URL scheme (angr://).")
self._url_scheme_text = QLineEdit()
self._url_scheme_text.setReadOnly(True)
url_scheme_lbl = QLabel("Currently registered to:")
os_layout = QVBoxLayout()
os_layout.addWidget(self._url_scheme_chk)
os_layout.addWidget(url_scheme_lbl)
os_layout.addWidget(self._url_scheme_text)
os_integration.setLayout(os_layout)
layout = QVBoxLayout()
layout.addWidget(os_integration)
layout.addStretch()
self.setLayout(layout)
def _load_config(self):
scheme = AngrUrlScheme()
try:
registered, register_as = scheme.is_url_scheme_registered()
self._url_scheme_chk.setChecked(registered)
self._url_scheme_text.setText(register_as)
except NotImplementedError:
# the current OS is not supported
self._url_scheme_chk.setDisabled(True)
def save_config(self):
scheme = AngrUrlScheme()
try:
registered, _ = scheme.is_url_scheme_registered()
if registered != self._url_scheme_chk.isChecked():
# we need to do something
if self._url_scheme_chk.isChecked():
scheme.register_url_scheme()
else:
scheme.unregister_url_scheme()
except NotImplementedError:
# the current OS is not supported
pass
def create_vary_checkbox(self, b):
cb = QCheckBox(self.ui.table)
cb.setChecked(b)
cb.toggled.connect(self.update_params)
self.vary_checkboxes.append(cb)
return self.create_table_widget(cb)
def setup_table(self, status=True):
self.ui.masks_table.setRowCount(0)
for i, key in enumerate(self.masks.keys()):
# Add label
self.ui.masks_table.insertRow(i)
self.ui.masks_table.setItem(i, 0, QTableWidgetItem(key))
# Add checkbox to toggle visibility
cb = QCheckBox()
status = key in HexrdConfig().visible_masks
cb.setChecked(status)
cb.setStyleSheet('margin-left:50%; margin-right:50%;')
cb.toggled.connect(self.toggle_visibility)
self.ui.masks_table.setCellWidget(i, 1, cb)
# Add push button to remove mask
pb = QPushButton('Remove Mask')
pb.clicked.connect(self.remove_mask)
self.ui.masks_table.setCellWidget(i, 2, pb)
# Connect manager to raw image mode tab settings
# for threshold mask
mtype, data = self.masks[key]
if mtype == 'threshold':
self.setup_threshold_connections(cb, pb)
def _layout(self):
layout = QFormLayout(self)
self.setLayout(layout)
tooltip_label = QLabel("Display tooltips as", self)
tooltip_field = QComboBox(self)
tooltip_field.insertItem(0, "Disabled")
tooltip_field.insertItem(1, "Notification") # XXX: Check support
tooltip_field.insertItem(2, "Cursor tooltip")
tooltip_field.currentIndexChanged.connect(self.preview_tooltip)
layout.addRow(tooltip_label, tooltip_field)
border_field = QCheckBox("Styled window border", self)
border_field.setDisabled(sys.platform == "darwin")
border_field.setChecked(sys.platform != "darwin")
layout.addRow(None, border_field)
# I think this doesn't belong to "Interface"
# either rename it to settings or make separate game tab
capturei_label = QLabel("Capture interval", self)
capturei_layout = QHBoxLayout()
capturei_field = QSpinBox(self)
capturei_field.setRange(100, 2000)
capturei_field.setSingleStep(100)
capturei_field.setValue(100)
capturei_layout.addWidget(capturei_field, 1)
capturei_unit = QLabel("ms", self)
capturei_layout.addWidget(capturei_unit, 0)
layout.addRow(capturei_label, capturei_layout)
def widget_from_description(x):
"""Dynamically create a widget from a description dict.
Some of the keys currently accepted are 'type', 'min', 'max', and
'tooltip'.
"""
if not x:
return
if x['type'] in (int, float):
# It's a spin box
widget_type = QSpinBox if x['type'] == int else ScientificDoubleSpinBox
widget = widget_type()
if 'max' in x:
widget.setMaximum(x['max'])
if 'min' in x:
widget.setMinimum(x['min'])
if 'value' in x:
widget.setValue(x['value'])
elif x['type'] == bool:
widget = QCheckBox()
if 'value' in x:
widget.setChecked(x)
if 'tooltip' in x:
widget.setToolTip(x['tooltip'])
return widget
def field_from_value(self, parent, value, field):
if isinstance(value, bool):
item = QCheckBox('')
item.setChecked(value)
return item
if isinstance(value, str):
field.text_type = STRING_SETTING
return QLineEdit(value)
if isinstance(value, numbers.Real):
field.text_type = NUMBER_SETTING
return QLineEdit(str(value))
if isinstance(value, list):
if isinstance(value[0], str):
field.text_type = STRING_LIST_SETTING
return QLineEdit(", ".join(value))
elif isinstance(value[0], numbers.Real):
field.text_type = NUMBER_LIST_SETTING
return QLineEdit(", ".join((str(x) for x in value)))
if isinstance(value, dict):
subpage = QGroupBox(parent)
form = QFormLayout()
for label in sorted(value.keys()):
subfield = Field(None, label)
subfield.widget = self.field_from_value(
subpage, value[label], subfield)
field.add_child(subfield)
form.addRow(QLabel(label), subfield.widget)
subpage.setLayout(form)
return subpage
# This is left for bug reporting purposes.
printer.out(
"{} was not assigned to {} because type {} is unknown.".format(
value, parent, type(value)))
return None
class App(QWidget):
"""The primary class"""
def __init__(self, parent=None):
super(App, self).__init__(parent)
self.layout = QVBoxLayout()
self.top_layout = QHBoxLayout()
self.open_button = QPushButton("Open")
self.open_button.clicked.connect(self.getfile)
self.top_layout.addWidget(self.open_button)
self.file_path = QLineEdit()
self.top_layout.addWidget(self.file_path)
self.dry_run_checkbox = QCheckBox("Dryrun")
self.dry_run_checkbox.setChecked(False)
self.dry_run_checkbox.toggled.connect(lambda: self.set_dry_run())
self.is_dryrun = False
self.top_layout.addWidget(self.dry_run_checkbox)
self.layout.addLayout(self.top_layout)
self.contents = QTextEdit()
self.layout.addWidget(self.contents)
self.help = "help"
self.bottom_layout = QHBoxLayout()
self.help_button = QPushButton("Help")
self.help_button.clicked.connect(lambda: self.set_info(self.help))
self.bottom_layout.addWidget(self.help_button)
self.bottom_layout.addStretch(1)
self.run_button = QPushButton("Run")
self.run_button.clicked.connect(self.fix_and_clean)
self.bottom_layout.addWidget(self.run_button)
self.layout.addLayout(self.bottom_layout)
self.setLayout(self.layout)
self.setWindowTitle("OpenMW NIF Converter")
self.processor = Processor(self.contents.append)
def getfile(self):
"""function to retrieve the directory to act on"""
acting_directory = QFileDialog.getExistingDirectory(
self, 'Open directory')
self.acting_directory = str(acting_directory)
self.file_path.setText(self.acting_directory)
def set_info(self, info):
"""Sets the contents of the notification TextEdit"""
self.contents.setText(info)
def fix_and_clean(self):
"""Runs the main processing script"""
self.processor.process_dir(self.directory, self.is_dryrun)
def set_dry_run(self):
"""Checks if the run will actually be attempted"""
if self.dry_run_checkbox.isChecked():
self.is_dryrun = True
def __init__(self, main_window, nodes_dict: dict, last_export_dir: str):
super(SaveDialog, self).__init__(parent=main_window)
self.create_UI()
self.main_window = main_window
self.nodes = nodes_dict
self.export_nodes = []
self.nodes_check_box_list = []
self.export_dir = last_export_dir
self.package_name = ''
self.set_package_name(self.export_dir)
# add node-checkboxes
node_keys = list(self.nodes.keys())
nodes_list_widget = self.nodes_scroll_area.takeWidget()
for i in range(len(node_keys)):
n = node_keys[i]
node_check_box = QCheckBox(n.title)
node_check_box.setObjectName('node_check_box_' + str(i))
node_check_box.setChecked(self.nodes[n])
nodes_list_widget.layout().addWidget(node_check_box)
self.nodes_check_box_list.append(node_check_box)
nodes_list_widget.adjustSize()
self.nodes_scroll_area.setWidget(nodes_list_widget)
def __init__(self, squadron: Squadron) -> None:
super().__init__()
self.squadron = squadron
self.allowed_mission_types = set()
self.addWidget(QLabel("Allowed mission types"))
def make_callback(toggled_task: FlightType) -> Callable[[bool], None]:
def callback(checked: bool) -> None:
self.on_toggled(toggled_task, checked)
return callback
for task in FlightType:
if task is FlightType.FERRY:
# Not plannable so just skip it.
continue
enabled = task in squadron.mission_types
if enabled:
self.allowed_mission_types.add(task)
checkbox = QCheckBox(text=task.value)
checkbox.setChecked(enabled)
checkbox.toggled.connect(make_callback(task))
self.addWidget(checkbox)
self.addStretch()
def _create_valid_checkbox(self, row: RowWidgets) -> QCheckBox:
valid_checkbox = QCheckBox(row.parent)
is_checked = True if row.fact is None else row.fact.is_valid
valid_checkbox.setChecked(is_checked)
valid_checkbox.stateChanged.connect(self.on_valid_changed)
valid_checkbox.row = row
return valid_checkbox
def save_image_dialog(self):
raw_image = False
checkBox = QCheckBox("Save raw image")
checkBox.setChecked(True)
msgBox = QMessageBox(self)
msgBox.setWindowTitle("Save Image")
msgBox.setText(
"Save the image displayed in the preview or the raw image from the camera"
)
msgBox.setIcon(QMessageBox.Question)
msgBox.addButton(QMessageBox.Ok)
msgBox.addButton(QMessageBox.Cancel)
msgBox.setDefaultButton(QMessageBox.Cancel)
msgBox.setCheckBox(checkBox)
val = msgBox.exec()
if val == QMessageBox.Cancel:
return
raw_image = msgBox.checkBox().isChecked()
now = datetime.now().strftime("%y-%m-%d_%H-%M")
save_path, filter = QFileDialog.getSaveFileName(
self, "Choose save file",
f"{userpaths.get_my_pictures()}/screenshot_{now}.png",
"Images (*.png *.jpg *.bmp)")
if save_path is None:
return
qimg = self.ui.camera_prev.grab_image(raw=raw_image)
if qimg is None:
return
qimg.save(save_path, quality=100)
class SuccessPage(QWizardPage):
def __init__(self, parent):
super().__init__(parent)
self.setTitle("Installation successful")
self._label = HyperTextLabel()
layout = QVBoxLayout(self)
use_julia_check_box = QCheckBox("Use this Julia with Spine Toolbox")
self._create_kernel_check_box = QCheckBox(
"Create a Jupyter kernel for this Julia")
self.registerField("use_julia", use_julia_check_box)
self.registerField("create_kernel", self._create_kernel_check_box)
layout.addWidget(self._label)
layout.addStretch()
layout.addWidget(use_julia_check_box)
layout.addWidget(self._create_kernel_check_box)
layout.addStretch()
layout.addStretch()
use_julia_check_box.clicked.connect(self._handle_use_julia_clicked)
@Slot(bool)
def _handle_use_julia_clicked(self, checked=False):
self._create_kernel_check_box.setChecked(checked)
self._create_kernel_check_box.setEnabled(checked)
def initializePage(self):
self._label.setText(
f"Julia executable created at <b>{self.wizard().julia_exe}</b>")
self.setField("use_julia", True)
self.setField("create_kernel", True)
def nextId(self):
return -1
class ScoresWidget(QDockWidget):
"""Widget that display a solution scores."""
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowTitle("Scores")
# Build widgets
self.search_field = QLineEdit(self)
self.checkbox_positive = QCheckBox("Positive", self)
self.checkbox_positive.setChecked(True)
self.checkbox_negative = QCheckBox("Negative", self)
self.checkbox_negative.setChecked(True)
self.checkbox_neutral = QCheckBox("Neutral", self)
self.table = QTableView(self)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.table.horizontalHeader().setStretchLastSection(True)
self.table.verticalHeader().setVisible(False)
# Build layout
layout_header = QHBoxLayout()
layout_header.addWidget(self.search_field)
layout_header.addWidget(self.checkbox_positive)
layout_header.addWidget(self.checkbox_negative)
layout_header.addWidget(self.checkbox_neutral)
layout_main = QVBoxLayout()
layout_main.addLayout(layout_header)
layout_main.addWidget(self.table)
main_widget = QWidget(self)
main_widget.setLayout(layout_main)
self.setWidget(main_widget)
# Configure models
self.model = PointsTableModel(self)
self._proxy_model = ScoreProxyModel()
self._proxy_model.setSourceModel(self.model)
self._proxy_model.sort(
1, Qt.AscendingOrder) # sort by lowest score by default
# Configure table
self.table.setModel(self._proxy_model)
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
# Connect signals
for signal, callback in (
(self.search_field.textChanged,
self._proxy_model.setFilterWildcard),
(self.checkbox_positive.stateChanged,
self._proxy_model.set_positive),
(self.checkbox_negative.stateChanged,
self._proxy_model.set_negative),
(self.checkbox_neutral.stateChanged,
self._proxy_model.set_neutral),
):
signal.connect(callback)
def displayWidgets(self):
"""
Configura os widgets da app
"""
grid = QGridLayout()
titl_lbl = QLabel("To Do List")
titl_lbl.setFont(QFont('Arial', 24))
titl_lbl.setAlignment(Qt.AlignCenter)
close_btn = QPushButton("Fechar")
close_btn.clicked.connect(self.close)
pend_lbl = QLabel("Tarefas")
pend_lbl.setFont(QFont('Arial', 20))
pend_lbl.setAlignment(Qt.AlignCenter)
comp_lbl = QLabel("Compromissos")
comp_lbl.setFont(QFont('Arial', 20))
comp_lbl.setAlignment(Qt.AlignCenter)
pend_grd = QGridLayout()
pend_grd.setContentsMargins(5, 5, 5, 5)
pend_grd.addWidget(pend_lbl, 0, 0, 1, 2)
for pos in range(1, 15):
cbox = QCheckBox()
cbox.setChecked(False)
ledit = QLineEdit()
ledit.setMinimumWidth(200)
pend_grd.addWidget(cbox, pos, 0)
pend_grd.addWidget(ledit, pos, 1)
mat_lbl = QLabel("Manhã")
mat_lbl.setFont(QFont('Arial', 16))
mat_tedit = QTextEdit()
ves_lbl = QLabel("Tarde")
ves_lbl.setFont(QFont('Arial', 16))
ves_tedit = QTextEdit()
not_lbl = QLabel("Noite")
not_lbl.setFont(QFont('Arial', 16))
not_tedit = QTextEdit()
vbox = QVBoxLayout()
vbox.setContentsMargins(5, 5, 5, 5)
vbox.addWidget(comp_lbl)
vbox.addWidget(mat_lbl)
vbox.addWidget(mat_tedit)
vbox.addWidget(ves_lbl)
vbox.addWidget(ves_tedit)
vbox.addWidget(not_lbl)
vbox.addWidget(not_tedit)
grid.addWidget(titl_lbl, 0, 0, 1, 2)
grid.addLayout(pend_grd, 1, 0)
grid.addLayout(vbox, 1, 1)
grid.addWidget(close_btn, 2, 0, 1, 2)
self.setLayout(grid)
def _property_checkbox(self, property_name, parent=None):
def wrapped(enabled):
setattr(self.model, property_name, enabled)
check_box = QCheckBox(parent)
check_box.setChecked(getattr(self.model, property_name))
check_box.toggled.connect(wrapped)
return check_box
class BitcoindConfigurationTab(QWidget):
def __init__(self, bitcoin: Bitcoin):
super().__init__()
self.bitcoin = bitcoin
self.layout = QGridLayout()
self.bitcoin_version = SelectableText(
f'Bitcoin Core '
f'version {self.bitcoin.software.release_version}')
self.layout.addWidget(self.bitcoin_version)
self.data_directory_group_box = DataDirectoryBox(bitcoin=self.bitcoin)
self.data_directory_group_box.file_dialog.new_data_directory.connect(
self.change_datadir)
self.layout.addWidget(self.data_directory_group_box)
self.layout.setAlignment(self.data_directory_group_box,
Qt.AlignHCenter)
self.enable_wallet_label = QLabel('Enable wallet')
self.enable_wallet_widget = QCheckBox('Enable Wallet')
self.enable_wallet_widget.setChecked(
not self.bitcoin.file['disablewallet'])
self.enable_wallet_widget.stateChanged.connect(
lambda x: self.set_conf_value('disablewallet', not bool(x)))
self.layout.addWidget(self.enable_wallet_widget)
self.layout.addWidget(HorizontalLine())
self.ports_layout = BitcoindPortsLayout(bitcoin=self.bitcoin)
self.layout.addLayout(self.ports_layout)
self.restart_layout = BitcoindRestartLayout(bitcoin=self.bitcoin)
self.layout.addLayout(self.restart_layout)
self.show_bitcoin_conf = QPushButton('Show bitcoin.conf')
self.show_bitcoin_conf.clicked.connect(
lambda: reveal(self.bitcoin.file.directory))
self.layout.addWidget(self.show_bitcoin_conf)
self.setLayout(self.layout)
def change_datadir(self, new_datadir: str):
self.bitcoin.file['datadir'] = new_datadir
self.bitcoin.set_prune()
self.data_directory_group_box.set_datadir(self.bitcoin.file['datadir'],
self.bitcoin.file['prune'])
@staticmethod
def set_checked(widget: QCheckBox, state: bool):
if state is None:
widget.setChecked(False)
return
widget.setChecked(state)
def set_conf_value(self, key: str, new_value):
self.bitcoin.file[key] = new_value
def __init__(self, parent):
super().__init__(parent)
layout = QVBoxLayout(self)
self.tabs = QTabWidget()
self.tabs.resize(300, 200)
layout.addWidget(self.tabs)
self.tab1 = QWidget()
self.tabs.addTab(self.tab1, "Tab 1")
print(self.tabs.currentIndex())
self.tab2 = QWidget()
self.tabs.addTab(self.tab2, "Tab 2")
print(self.tabs.currentIndex())
lay1 = QGridLayout(self.tab1)
self.checkbox_states1 = {}
for i, (key, text) in enumerate((
("Haar", "small"),
("db", "small"),
("sym", "small"),
("coif", "very very very very long"),
)):
checkbox = QCheckBox(text)
checkbox.setChecked(False)
lay1.addWidget(checkbox, i, 0)
self.checkbox_states1[key] = checkbox
self.process_wavelet1 = QPushButton("Process")
lay1.addWidget(self.process_wavelet1, i, 1)
QObject.connect(self.process_wavelet1, SIGNAL('clicked()'),
self._on_process_wavelet)
self.process_wavelet2 = QPushButton("suppr")
lay1.addWidget(self.process_wavelet2, i + 1, 1)
QObject.connect(self.process_wavelet2, SIGNAL('clicked()'), self.suppr)
lay = QGridLayout(self.tab2)
self.checkbox_states = {}
for i, (key, text) in enumerate((
("Haar", "small"),
("db", "small"),
("sym", "small"),
("coif", "very very very very long"),
)):
checkbox = QCheckBox(text)
checkbox.setChecked(False)
lay.addWidget(checkbox, i, 0)
self.checkbox_states[key] = checkbox
self.process_wavelet = QPushButton("Process")
lay.addWidget(self.process_wavelet, i, 1)
QObject.connect(self.process_wavelet, SIGNAL('clicked()'),
self._on_process_wavelet)
class BitcoinTab(QWidget):
change_network = Signal(Network)
def __init__(self, bitcoin: Bitcoin):
super().__init__()
self.bitcoin = bitcoin
self.bitcoin_layout = QVBoxLayout()
self.data_directory_group_box = DataDirectoryBox()
self.data_directory_group_box.file_dialog.new_data_directory.connect(
self.change_datadir)
self.data_directory_group_box.set_datadir(self.bitcoin.file['datadir'],
self.bitcoin.file['prune'])
self.bitcoin_layout.addWidget(self.data_directory_group_box)
self.bitcoin_layout.setAlignment(self.data_directory_group_box,
Qt.AlignHCenter)
self.enable_wallet_label = QLabel('Enable wallet')
self.enable_wallet_widget = QCheckBox('Enable Wallet')
self.enable_wallet_widget.setChecked(
not self.bitcoin.file['disablewallet'])
self.enable_wallet_widget.stateChanged.connect(
lambda x: self.update_config('disablewallet', not bool(x)))
self.bitcoin_layout.addWidget(self.enable_wallet_widget)
self.enable_testnet_label = QLabel('Enable testnet')
self.enable_testnet_widget = QCheckBox('Enable Testnet')
self.set_checked(self.enable_testnet_widget,
self.bitcoin.file['testnet'])
self.enable_testnet_widget.stateChanged.connect(
lambda x: self.update_config('testnet', bool(x)))
self.bitcoin_layout.addWidget(self.enable_testnet_widget)
self.setLayout(self.bitcoin_layout)
def change_datadir(self, new_datadir: str):
self.bitcoin.file['datadir'] = new_datadir
self.bitcoin.set_prune()
self.data_directory_group_box.set_datadir(self.bitcoin.file['datadir'],
self.bitcoin.file['prune'])
@staticmethod
def set_checked(widget: QCheckBox, state: bool):
if state is None:
widget.setChecked(False)
return
widget.setChecked(state)
def update_config(self, name: str, state: bool):
self.bitcoin.file[name] = state
if name == 'testnet' and state:
self.change_network.emit(TESTNET)
elif name == 'testnet' and not state:
self.change_network.emit(MAINNET)
def _set_ui_tab2(self):
""""
_set_ui_tab2
@:brief
Set user interface of the second tab : wavelet processing tab
see pywt documentation
@:parameter
self
@:return
None
"""
lay = QGridLayout(self.tab2)
label = QLabel("Wavelet family :")
lay.addWidget(label, 0, 1)
# all possible method for wevelet processing
for i, (key, text) in enumerate((
("haar", "Haar"),
("db", "daubechies"),
("sym", "Symlets"),
("coif", "Coiflets"),
("bior", "biorthogonal"),
("rbio", "reverse-biorthogonal"),
("dmey", "Discret FIR Meyer"),
("gaus", "gaussian"),
("mexh", "Mexican hat"),
("morl", "morlet"),
("cgau", "Complex Gaussian"),
("shan", "Shanon"),
("fbsp", "Frequency B-Spline"),
("cmor", "Complex Morlet"),
)):
checkbox = QCheckBox(text)
checkbox.setChecked(False)
lay.addWidget(checkbox, i + 1, 1)
self.checkbox_states[key] = checkbox
# set combo box with method
self.wavelet_combo_box[key] = QComboBox()
l = pywt.wavelist(key)
self.wavelet_combo_box[key].addItems(l)
lay.addWidget(self.wavelet_combo_box[key], i + 1, 2)
# choose order of decomposition
label_order_decomp = QLabel("choose order of decomposition : \t")
lay.addWidget(label_order_decomp, 0, 0)
self.order_decomp = QLineEdit()
lay.addWidget(self.order_decomp, 1, 0)
self.process_wavelet = QPushButton("Process")
QObject.connect(self.process_wavelet, SIGNAL('clicked()'),
self._on_process_wavelet)
lay.addWidget(self.process_wavelet, i + 2, 3)
self.tab2.setLayout(lay)
def __init__(self, boxes, checks, parent=None):
QHBoxLayout.__init__(self)
self.setSpacing(0)
self.group = QButtonGroup()
self.group.setExclusive(False)
for i, (box, check) in enumerate(zip(boxes, checks)):
cbx = QCheckBox(box)
cbx.setChecked(eval(check))
self.addWidget(cbx)
self.group.addButton(cbx, i)
def testSignalMapper(self):
checkboxMapper = QSignalMapper()
box = QCheckBox('check me')
box.stateChanged.connect(checkboxMapper.map)
checkboxMapper.setMapping(box, box.text())
checkboxMapper.mapped[str].connect(self.cb_changed)
self._changed = False
box.setChecked(True)
self.assert_(self._changed)
def testSignalMapper(self):
checkboxMapper = QSignalMapper()
box = QCheckBox('check me')
box.stateChanged.connect(checkboxMapper.map)
checkboxMapper.setMapping(box, box.text())
checkboxMapper.mapped[str].connect(self.cb_changed)
self._changed = False
box.setChecked(True)
self.assertTrue(self._changed)
class Preferences(QMainWindow):
def __init__(self, app, default, qmp, tt):
QMainWindow.__init__(self)
self.app = app
self.default = default
self.qmp = qmp
self.init_ui()
self.show()
def init_ui(self):
self.setWindowTitle('Preferences')
self.setGeometry(100, 100, 400, 200)
grid = QVBoxLayout()
grid.setSpacing(15)
self.darkmode = QCheckBox('Dark Mode', self)
self.app.setStyle("Fusion")
if QGuiApplication.palette() != self.default:
self.darkmode.setChecked(True)
palette = QPalette()
palette.setColor(QPalette.Window, QColor(25, 25, 25)) # 53 53 53
palette.setColor(QPalette.WindowText, Qt.white)
palette.setColor(QPalette.Base, QColor(53, 53, 53)) # 25 25 25
palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
palette.setColor(QPalette.ToolTipBase, Qt.white)
palette.setColor(QPalette.ToolTipText, Qt.white)
palette.setColor(QPalette.Text, Qt.white)
palette.setColor(QPalette.Button, QColor(53, 53, 53))
palette.setColor(QPalette.ButtonText, Qt.white)
palette.setColor(QPalette.BrightText, Qt.red)
palette.setColor(QPalette.Link, QColor(42, 130, 218))
palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
palette.setColor(QPalette.HighlightedText, Qt.black)
self.darkmode.toggled.connect(lambda: self.app.setPalette(palette)
if self.darkmode.isChecked() else self.
app.setPalette(self.default))
grid.addWidget(self.darkmode, 1)
center = QWidget()
center.setLayout(grid)
self.setCentralWidget(center)
self.show()
def __init__(self, modules: dict, parent=None):
super(CodeGenDialog, self).__init__(parent)
self.modules = modules
main_layout = QVBoxLayout()
imports_group_box = QGroupBox('Imports')
imports_group_box.setLayout(QVBoxLayout())
info_text_edit = QPlainTextEdit(
'''I found the following imports in the inspected components. Please unselect all imports whose source code you want me to include in the output. All checked modules remain imported using the import statements. Notice that import alias names (import ... as ...) of course won\'t work when including the module\'s source. Same goes for imports using 'from' (indicated in the list below). And for those, the whole (direct) source will be included if you unselect a module.'''
)
info_text_edit.setReadOnly(True)
imports_group_box.layout().addWidget(info_text_edit)
imports_scroll_area = QScrollArea()
imports_scroll_area.setLayout(QVBoxLayout())
self.import_widget_assignment = {'imports': {}, 'fromimports': {}}
# imports
imports_scroll_area.layout().addWidget(QLabel('imports:'))
for i in modules['imports'].keys():
import_check_box = QCheckBox(i)
import_check_box.setChecked(True)
imports_scroll_area.layout().addWidget(import_check_box)
self.import_widget_assignment['imports'][import_check_box] = i
# from-imports
imports_scroll_area.layout().addWidget(QLabel('\'from\'-imports:'))
for i in modules['fromimports'].keys():
names = modules['fromimports'][i][2]
from_names_list = ', '.join(names)
import_check_box = QCheckBox(i + ': ' + from_names_list)
import_check_box.setChecked(True)
imports_scroll_area.layout().addWidget(import_check_box)
self.import_widget_assignment['fromimports'][import_check_box] = i
imports_group_box.layout().addWidget(imports_scroll_area)
main_layout.addWidget(imports_group_box)
button_box = QDialogButtonBox()
button_box.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
main_layout.addWidget(button_box)
self.setLayout(main_layout)
self.resize(500, 500)
self.setWindowTitle('Source Code Gen Manager')
class Window(QWidget):
def __init__(self):
super(Window, self).__init__()
self.renderArea = RenderArea()
self.shapeComboBox = QComboBox()
self.shapeComboBox.addItem("Polygon", RenderArea.Polygon)
self.shapeComboBox.addItem("Rectangle", RenderArea.Rect)
self.shapeComboBox.addItem("Rounded Rectangle", RenderArea.RoundedRect)
self.shapeComboBox.addItem("Ellipse", RenderArea.Ellipse)
self.shapeComboBox.addItem("Pie", RenderArea.Pie)
self.shapeComboBox.addItem("Chord", RenderArea.Chord)
self.shapeComboBox.addItem("Path", RenderArea.Path)
self.shapeComboBox.addItem("Line", RenderArea.Line)
self.shapeComboBox.addItem("Polyline", RenderArea.Polyline)
self.shapeComboBox.addItem("Arc", RenderArea.Arc)
self.shapeComboBox.addItem("Points", RenderArea.Points)
self.shapeComboBox.addItem("Text", RenderArea.Text)
self.shapeComboBox.addItem("Pixmap", RenderArea.Pixmap)
shapeLabel = QLabel("&Shape:")
shapeLabel.setBuddy(self.shapeComboBox)
self.penWidthSpinBox = QSpinBox()
self.penWidthSpinBox.setRange(0, 20)
self.penWidthSpinBox.setSpecialValueText("0 (cosmetic pen)")
penWidthLabel = QLabel("Pen &Width:")
penWidthLabel.setBuddy(self.penWidthSpinBox)
self.penStyleComboBox = QComboBox()
self.penStyleComboBox.addItem("Solid", Qt.SolidLine)
self.penStyleComboBox.addItem("Dash", Qt.DashLine)
self.penStyleComboBox.addItem("Dot", Qt.DotLine)
self.penStyleComboBox.addItem("Dash Dot", Qt.DashDotLine)
self.penStyleComboBox.addItem("Dash Dot Dot", Qt.DashDotDotLine)
self.penStyleComboBox.addItem("None", Qt.NoPen)
penStyleLabel = QLabel("&Pen Style:")
penStyleLabel.setBuddy(self.penStyleComboBox)
self.penCapComboBox = QComboBox()
self.penCapComboBox.addItem("Flat", Qt.FlatCap)
self.penCapComboBox.addItem("Square", Qt.SquareCap)
self.penCapComboBox.addItem("Round", Qt.RoundCap)
penCapLabel = QLabel("Pen &Cap:")
penCapLabel.setBuddy(self.penCapComboBox)
self.penJoinComboBox = QComboBox()
self.penJoinComboBox.addItem("Miter", Qt.MiterJoin)
self.penJoinComboBox.addItem("Bevel", Qt.BevelJoin)
self.penJoinComboBox.addItem("Round", Qt.RoundJoin)
penJoinLabel = QLabel("Pen &Join:")
penJoinLabel.setBuddy(self.penJoinComboBox)
self.brushStyleComboBox = QComboBox()
self.brushStyleComboBox.addItem("Linear Gradient",
Qt.LinearGradientPattern)
self.brushStyleComboBox.addItem("Radial Gradient",
Qt.RadialGradientPattern)
self.brushStyleComboBox.addItem("Conical Gradient",
Qt.ConicalGradientPattern)
self.brushStyleComboBox.addItem("Texture", Qt.TexturePattern)
self.brushStyleComboBox.addItem("Solid", Qt.SolidPattern)
self.brushStyleComboBox.addItem("Horizontal", Qt.HorPattern)
self.brushStyleComboBox.addItem("Vertical", Qt.VerPattern)
self.brushStyleComboBox.addItem("Cross", Qt.CrossPattern)
self.brushStyleComboBox.addItem("Backward Diagonal", Qt.BDiagPattern)
self.brushStyleComboBox.addItem("Forward Diagonal", Qt.FDiagPattern)
self.brushStyleComboBox.addItem("Diagonal Cross", Qt.DiagCrossPattern)
self.brushStyleComboBox.addItem("Dense 1", Qt.Dense1Pattern)
self.brushStyleComboBox.addItem("Dense 2", Qt.Dense2Pattern)
self.brushStyleComboBox.addItem("Dense 3", Qt.Dense3Pattern)
self.brushStyleComboBox.addItem("Dense 4", Qt.Dense4Pattern)
self.brushStyleComboBox.addItem("Dense 5", Qt.Dense5Pattern)
self.brushStyleComboBox.addItem("Dense 6", Qt.Dense6Pattern)
self.brushStyleComboBox.addItem("Dense 7", Qt.Dense7Pattern)
self.brushStyleComboBox.addItem("None", Qt.NoBrush)
brushStyleLabel = QLabel("&Brush Style:")
brushStyleLabel.setBuddy(self.brushStyleComboBox)
otherOptionsLabel = QLabel("Other Options:")
self.antialiasingCheckBox = QCheckBox("&Antialiasing")
self.transformationsCheckBox = QCheckBox("&Transformations")
self.shapeComboBox.activated.connect(self.shapeChanged)
self.penWidthSpinBox.valueChanged.connect(self.penChanged)
self.penStyleComboBox.activated.connect(self.penChanged)
self.penCapComboBox.activated.connect(self.penChanged)
self.penJoinComboBox.activated.connect(self.penChanged)
self.brushStyleComboBox.activated.connect(self.brushChanged)
self.antialiasingCheckBox.toggled.connect(self.renderArea.setAntialiased)
self.transformationsCheckBox.toggled.connect(self.renderArea.setTransformed)
mainLayout = QGridLayout()
mainLayout.setColumnStretch(0, 1)
mainLayout.setColumnStretch(3, 1)
mainLayout.addWidget(self.renderArea, 0, 0, 1, 4)
mainLayout.setRowMinimumHeight(1, 6)
mainLayout.addWidget(shapeLabel, 2, 1, Qt.AlignRight)
mainLayout.addWidget(self.shapeComboBox, 2, 2)
mainLayout.addWidget(penWidthLabel, 3, 1, Qt.AlignRight)
mainLayout.addWidget(self.penWidthSpinBox, 3, 2)
mainLayout.addWidget(penStyleLabel, 4, 1, Qt.AlignRight)
mainLayout.addWidget(self.penStyleComboBox, 4, 2)
mainLayout.addWidget(penCapLabel, 5, 1, Qt.AlignRight)
mainLayout.addWidget(self.penCapComboBox, 5, 2)
mainLayout.addWidget(penJoinLabel, 6, 1, Qt.AlignRight)
mainLayout.addWidget(self.penJoinComboBox, 6, 2)
mainLayout.addWidget(brushStyleLabel, 7, 1, Qt.AlignRight)
mainLayout.addWidget(self.brushStyleComboBox, 7, 2)
mainLayout.setRowMinimumHeight(8, 6)
mainLayout.addWidget(otherOptionsLabel, 9, 1, Qt.AlignRight)
mainLayout.addWidget(self.antialiasingCheckBox, 9, 2)
mainLayout.addWidget(self.transformationsCheckBox, 10, 2)
self.setLayout(mainLayout)
self.shapeChanged()
self.penChanged()
self.brushChanged()
self.antialiasingCheckBox.setChecked(True)
self.setWindowTitle("Basic Drawing")
def shapeChanged(self):
shape = self.shapeComboBox.itemData(self.shapeComboBox.currentIndex(),
IdRole)
self.renderArea.setShape(shape)
def penChanged(self):
width = self.penWidthSpinBox.value()
style = Qt.PenStyle(self.penStyleComboBox.itemData(
self.penStyleComboBox.currentIndex(), IdRole))
cap = Qt.PenCapStyle(self.penCapComboBox.itemData(
self.penCapComboBox.currentIndex(), IdRole))
join = Qt.PenJoinStyle(self.penJoinComboBox.itemData(
self.penJoinComboBox.currentIndex(), IdRole))
self.renderArea.setPen(QPen(Qt.blue, width, style, cap, join))
def brushChanged(self):
style = Qt.BrushStyle(self.brushStyleComboBox.itemData(
self.brushStyleComboBox.currentIndex(), IdRole))
if style == Qt.LinearGradientPattern:
linearGradient = QLinearGradient(0, 0, 100, 100)
linearGradient.setColorAt(0.0, Qt.white)
linearGradient.setColorAt(0.2, Qt.green)
linearGradient.setColorAt(1.0, Qt.black)
self.renderArea.setBrush(QBrush(linearGradient))
elif style == Qt.RadialGradientPattern:
radialGradient = QRadialGradient(50, 50, 50, 70, 70)
radialGradient.setColorAt(0.0, Qt.white)
radialGradient.setColorAt(0.2, Qt.green)
radialGradient.setColorAt(1.0, Qt.black)
self.renderArea.setBrush(QBrush(radialGradient))
elif style == Qt.ConicalGradientPattern:
conicalGradient = QConicalGradient(50, 50, 150)
conicalGradient.setColorAt(0.0, Qt.white)
conicalGradient.setColorAt(0.2, Qt.green)
conicalGradient.setColorAt(1.0, Qt.black)
self.renderArea.setBrush(QBrush(conicalGradient))
elif style == Qt.TexturePattern:
self.renderArea.setBrush(QBrush(QPixmap(':/images/brick.png')))
else:
self.renderArea.setBrush(QBrush(Qt.green, style))
class MainWindow(QMainWindow):
def __init__(self, app, parent=None):
super(MainWindow, self).__init__(parent)
self.imagesDir = app.dir + '/images/'
self.setWindowIcon(QIcon(self.imagesDir + 'icon.png'))
self.path = ''
self.settings = QSettings()
self.lastDir = self.settings.value('lastDir', '')
self.setMinimumWidth(540)
self.supportedFormats = []
for f in QImageReader.supportedImageFormats():
self.supportedFormats.append(str(f.data(), encoding="utf-8"))
self.fileWatcher = QFileSystemWatcher()
self.fileWatcher.fileChanged.connect(self.fileChanged)
# widgets
self.showPixmapWidget = None
self.tileWidthSpinBox = QSpinBox()
self.tileWidthSpinBox.setValue(16)
self.tileWidthSpinBox.setFixedWidth(50)
self.tileWidthSpinBox.setMinimum(1)
self.tileHeightSpinBox = QSpinBox()
self.tileHeightSpinBox.setValue(16)
self.tileHeightSpinBox.setFixedWidth(50)
self.tileHeightSpinBox.setMinimum(1)
self.paddingSpinBox = QSpinBox()
self.paddingSpinBox.setFixedWidth(50)
self.paddingSpinBox.setMinimum(1)
self.transparentCheckbox = QCheckBox("Transparent")
self.transparentCheckbox.setChecked(True)
self.transparentCheckbox.stateChanged.connect(self.transparentChanged)
self.backgroundColorEdit = ColorEdit()
self.backgroundColorEdit.setEnabled(False)
self.backgroundColorLabel = QLabel("Background color:")
self.backgroundColorLabel.setEnabled(False)
self.forcePotCheckBox = QCheckBox("Force PoT")
self.forcePotCheckBox.setChecked(True)
self.forcePotCheckBox.stateChanged.connect(self.forcePotChanged)
self.reorderTilesCheckBox = QCheckBox("Reorder tiles")
self.generateAndExportButton = QPushButton("Generate and export")
self.generateAndExportButton.setFixedHeight(32)
self.generateAndExportButton.clicked.connect(self.generateAndExportClicked)
self.generateAndExportButton.setEnabled(False)
self.pixmapWidget = PixmapWidget()
self.pixmapWidget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.pixmapWidget.setPixmap(self.createDropTextPixmap())
self.pixmapWidget.dropSignal.connect(self.fileDropped)
self.pixmapWidget.setMinimumHeight(300)
# load settings
self.tileWidthSpinBox.setValue(int(self.settings.value('tileWidth', 16)))
self.tileHeightSpinBox.setValue(int(self.settings.value('tileHeight', 16)))
self.paddingSpinBox.setValue(int(self.settings.value('padding', 1)))
self.forcePotCheckBox.setChecked(True if self.settings.value('forcePot', 'true') == 'true' else False)
self.reorderTilesCheckBox.setChecked(True if self.settings.value('reorderTiles', 'false') == 'true' else False)
self.transparentCheckbox.setChecked(True if self.settings.value('transparent', 'false') == 'true' else False)
self.backgroundColorEdit.setColorText(str(self.settings.value('backgroundColor', '#FF00FF')))
self.restoreGeometry(QByteArray(self.settings.value('MainWindow/geometry')))
self.restoreState(QByteArray(self.settings.value('MainWindow/windowState')))
# layout
hl1 = QHBoxLayout()
hl1.setContentsMargins(5, 5, 5, 5)
hl1.addWidget(QLabel("Tile width:"))
hl1.addSpacing(5)
hl1.addWidget(self.tileWidthSpinBox)
hl1.addSpacing(15)
hl1.addWidget(QLabel("Tile height:"))
hl1.addSpacing(5)
hl1.addWidget(self.tileHeightSpinBox)
hl1.addSpacing(15)
hl1.addWidget(QLabel("Padding:"))
hl1.addSpacing(5)
hl1.addWidget(self.paddingSpinBox)
hl1.addSpacing(15)
hl1.addWidget(self.forcePotCheckBox)
hl1.addSpacing(15)
hl1.addWidget(self.reorderTilesCheckBox)
hl1.addStretch()
hl2 = QHBoxLayout()
hl2.setContentsMargins(5, 5, 5, 5)
hl2.addWidget(self.transparentCheckbox)
hl2.addSpacing(15)
hl2.addWidget(self.backgroundColorLabel)
hl2.addSpacing(5)
hl2.addWidget(self.backgroundColorEdit)
hl2.addStretch()
hl3 = QHBoxLayout()
hl3.setContentsMargins(5, 5, 5, 5)
hl3.addWidget(self.generateAndExportButton)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.setSpacing(0)
vl.addLayout(hl1)
vl.addLayout(hl2)
vl.addWidget(self.pixmapWidget)
vl.addLayout(hl3)
w = QWidget()
w.setLayout(vl)
self.setCentralWidget(w)
self.setTitle()
def setTitle(self):
p = ' - ' + os.path.basename(self.path) if self.path else ''
self.setWindowTitle(QCoreApplication.applicationName() + ' ' + QCoreApplication.applicationVersion() + p)
def createDropTextPixmap(self):
pixmap = QPixmap(481, 300)
pixmap.fill(QColor("#333333"))
painter = QPainter(pixmap)
font = QFont("Arial")
font.setPixelSize(28)
font.setBold(True)
fm = QFontMetrics(font)
painter.setFont(font)
painter.setPen(QPen(QColor("#888888"), 1))
text = "Drop the tileset image here"
x = (pixmap.width()-fm.width(text))/2
y = (pixmap.height()+fm.height())/2
painter.drawText(x, y, text)
del painter
return pixmap
def fileDropped(self, path):
path = str(path)
name, ext = os.path.splitext(path)
ext = ext[1:]
if not ext in self.supportedFormats:
QMessageBox.warning(self, "Warning", "The dropped file is not supported")
return
pixmap = QPixmap(path)
if pixmap.isNull():
QMessageBox.warning(self, "Warning", "Can't load the image")
return
if self.path:
self.fileWatcher.removePath(self.path)
self.path = path
self.fileWatcher.addPath(self.path)
self.pixmapWidget.setPixmap(pixmap)
self.generateAndExportButton.setEnabled(True)
self.setTitle()
self.activateWindow()
def fileChanged(self, path):
#self.fileDropped(path)
pass
def transparentChanged(self):
e = self.transparentCheckbox.isChecked()
self.backgroundColorEdit.setEnabled(not e)
self.backgroundColorLabel.setEnabled(not e)
def forcePotChanged(self):
e = self.forcePotCheckBox.isChecked()
self.reorderTilesCheckBox.setEnabled(e)
def generateAndExportClicked(self):
g = Generator()
g.tileWidth = self.tileWidthSpinBox.value()
g.tileHeight = self.tileHeightSpinBox.value()
g.forcePot = self.forcePotCheckBox.isChecked()
g.isTransparent = self.transparentCheckbox.isChecked()
g.bgColor = self.backgroundColorEdit.getColor()
g.reorder = self.reorderTilesCheckBox.isChecked()
g.padding = self.paddingSpinBox.value()
target = g.create(self.pixmapWidget.pixmap);
# export
self.lastDir = os.path.dirname(self.path)
targetPath = QFileDialog.getSaveFileName(self, 'Export', self.lastDir, 'PNG (*.png)')
if targetPath:
target.save(targetPath[0])
showPixmap = QPixmap.fromImage(target)
if self.showPixmapWidget:
self.showPixmapWidget.deleteLater()
del self.showPixmapWidget
self.showPixmapWidget = PixmapWidget()
self.showPixmapWidget.setWindowIcon(self.windowIcon())
self.showPixmapWidget.setWindowTitle(os.path.basename(targetPath[0]))
self.showPixmapWidget.resize(showPixmap.width(), showPixmap.height())
self.showPixmapWidget.setPixmap(showPixmap)
self.showPixmapWidget.show()
def closeEvent(self, event):
if self.showPixmapWidget:
self.showPixmapWidget.close()
# save settings
self.settings.setValue('tileWidth', self.tileWidthSpinBox.value())
self.settings.setValue('tileHeight', self.tileHeightSpinBox.value())
self.settings.setValue('padding', self.paddingSpinBox.value())
self.settings.setValue('forcePot', self.forcePotCheckBox.isChecked())
self.settings.setValue('reorderTiles', self.reorderTilesCheckBox.isChecked())
self.settings.setValue('transparent', self.transparentCheckbox.isChecked())
self.settings.setValue('backgroundColor', self.backgroundColorEdit.getColor().name())
self.settings.setValue('lastDir', self.lastDir)
self.settings.setValue('MainWindow/geometry', self.saveGeometry())
self.settings.setValue('MainWindow/windowState', self.saveState())
super(MainWindow, self).closeEvent(event)
def testSimpleSignal(self):
box = QCheckBox('check me')
box.stateChanged[int].connect(self.cb_changedVoid)
self._changed = False
box.setChecked(True)
self.assert_(self._changed)
class UserExportedAttributeWidget(mayaMixin.MayaQWidgetDockableMixin, QWidget):
_currentInstance = None
@classmethod
def closeCurrentInstance(cls):
if cls._currentInstance is not None:
if cls._currentInstance._mayaSelectionChangedJob is not None:
cmds.scriptJob(kill=cls._currentInstance._mayaSelectionChangedJob)
cls._currentInstance._mayaSelectionChangedJob = None
if cls._currentInstance._mayaUndoJob is not None:
cmds.scriptJob(kill=cls._currentInstance._mayaUndoJob)
cls._currentInstance._mayaUndoJob = None
if cls._currentInstance._mayaRedoJob is not None:
cmds.scriptJob(kill=cls._currentInstance._mayaRedoJob)
cls._currentInstance._mayaRedoJob = None
cls._currentInstance.close()
cls._currentInstance = None
def __init__(self, parent=None):
UserExportedAttributeWidget.closeCurrentInstance()
super(UserExportedAttributeWidget, self).__init__(parent=parent)
self._setupUI()
self._mayaSelectionChangedJob = cmds.scriptJob(event=["SelectionChanged", self._syncUI])
self._mayaUndoJob = cmds.scriptJob(event=["Undo", self._syncUI])
self._mayaRedoJob = cmds.scriptJob(event=["Redo", self._syncUI])
UserExportedAttributeWidget._currentInstance = self
# Force a sync on the first load.
self._syncUI()
def _setupUI(self):
self.setWindowTitle("Export Attributes to USD")
layout = QVBoxLayout()
# This section contains the attributes tagged for export.
label = QLabel()
label.setText('Exported Attributes:')
layout.addWidget(label)
self.exportedAttrsModel = ExportedAttributesModel()
self.exportedAttrsView = ExportedAttributesView()
self.exportedAttrsView.verticalHeader().hide()
self.exportedAttrsView.setModel(self.exportedAttrsModel)
selectionModel = self.exportedAttrsView.selectionModel()
selectionModel.selectionChanged.connect(self._onExportedAttrsSelectionChanged)
self.exportedAttrsModel.dataChanged.connect(self._onModelDataChanged)
layout.addWidget(self.exportedAttrsView)
self.removeExportedAttrButton = QPushButton("Remove Exported Attribute")
self.removeExportedAttrButton.clicked.connect(self._onRemoveExportedAttrPressed)
self.removeExportedAttrButton.setEnabled(False)
layout.addWidget(self.removeExportedAttrButton)
# This section contains the attributes available for export.
label = QLabel()
label.setText('Available Attributes:')
layout.addWidget(label)
self.userDefinedCheckBox = QCheckBox('User Defined')
self.userDefinedCheckBox.setToolTip('Show only user-defined (dynamic) attributes')
self.userDefinedCheckBox.setChecked(True)
self.userDefinedCheckBox.stateChanged.connect(self._syncUI)
layout.addWidget(self.userDefinedCheckBox)
self.addAttrsModel = AddAttributesModel()
self.addAttrsView = AddAttributesView()
self.addAttrsView.setModel(self.addAttrsModel)
selectionModel = self.addAttrsView.selectionModel()
selectionModel.selectionChanged.connect(self._onAddAttrsSelectionChanged)
self.addAttrsModel.dataChanged.connect(self._onModelDataChanged)
layout.addWidget(self.addAttrsView)
self.addExportedAttrButton = QPushButton("Add Exported Attribute")
self.addExportedAttrButton.clicked.connect(self._onAddExportedAttrPressed)
self.addExportedAttrButton.setEnabled(False)
layout.addWidget(self.addExportedAttrButton)
self.setLayout(layout)
def _onExportedAttrsSelectionChanged(self, selected, deselected):
if selected.isEmpty():
self.removeExportedAttrButton.setEnabled(False)
else:
self.removeExportedAttrButton.setEnabled(True)
def _onAddAttrsSelectionChanged(self, selected, deselected):
if selected.isEmpty():
self.addExportedAttrButton.setEnabled(False)
else:
self.addExportedAttrButton.setEnabled(True)
def _onRemoveExportedAttrPressed(self):
selectedNodeNames = cmds.ls(selection=True, long=True)
if not selectedNodeNames:
return
mayaAttrNames = [x.data() for x in self.exportedAttrsView.selectedIndexes()]
if not mayaAttrNames:
return
for selectedNodeName in selectedNodeNames:
ExportedAttribute.RemoveExportedAttributesForNode(selectedNodeName,
mayaAttrNames)
self._syncUI()
def _onAddExportedAttrPressed(self):
selectedNodeNames = cmds.ls(selection=True, long=True)
if not selectedNodeNames:
return
exportedAttrs = [ExportedAttribute(x.data()) for x in self.addAttrsView.selectedIndexes()]
if not exportedAttrs:
return
for selectedNodeName in selectedNodeNames:
ExportedAttribute.UpdateExportedAttributesForNode(selectedNodeName,
exportedAttrs)
self._syncUI()
def _onModelDataChanged(self, topLeft, bottomRight):
self._syncUI()
def _syncUI(self):
# Since _syncUI is called in response to events that invalidate/clear
# the selections in the views, disable the buttons until something is
# selected again.
self.removeExportedAttrButton.setEnabled(False)
self.addExportedAttrButton.setEnabled(False)
selectedNodeNames = cmds.ls(selection=True, long=True)
if not selectedNodeNames:
self.addAttrsModel.setStringList([])
self.exportedAttrsModel.exportedAttributes = []
self.exportedAttrsView.resizeColumnsToContents()
return
# Collect the export attributes common to all selected nodes. If the
# same attribute is configured differently on multiple objects (e.g.
# different usdAttrName), then do not include that attribute.
allExportedAttributeNames = set()
commonExportedAttributeNames = set()
commonExportedAttrs = {}
for exportedAttr in ExportedAttribute.GetExportedAttributesFromNode(selectedNodeNames[0]):
mayaAttrName = exportedAttr.mayaAttrName
allExportedAttributeNames.add(mayaAttrName)
commonExportedAttributeNames.add(mayaAttrName)
commonExportedAttrs[mayaAttrName] = exportedAttr
for selectedNodeName in selectedNodeNames[1:]:
exportedAttrNames = set()
for exportedAttr in ExportedAttribute.GetExportedAttributesFromNode(selectedNodeName):
mayaAttrName = exportedAttr.mayaAttrName
allExportedAttributeNames.add(mayaAttrName)
if (mayaAttrName in commonExportedAttrs and
commonExportedAttrs[mayaAttrName] == exportedAttr):
exportedAttrNames.add(mayaAttrName)
commonExportedAttributeNames.intersection_update(exportedAttrNames)
commonExportedAttrs = [commonExportedAttrs[x] for x in commonExportedAttributeNames]
commonExportedAttrs.sort(key=lambda x: x.mayaAttrName)
self.exportedAttrsModel.exportedAttributes = commonExportedAttrs
# Normally, the combo boxes for selecting usdAttrType and
# primvarInterpolation would only appear when the table cell is put into
# edit mode. Instead, we want the combo boxes to always be visible, so
# we tell the view to open them as persistent editors.
for row in xrange(self.exportedAttrsModel.rowCount()):
usdAttrTypeIndex = self.exportedAttrsModel.index(row,
ExportedAttributesModel.USD_ATTR_TYPE_COLUMN)
self.exportedAttrsView.openPersistentEditor(usdAttrTypeIndex)
# Only open the interpolation editor if this is a primvar.
if self.exportedAttrsModel.data(usdAttrTypeIndex) == USD_ATTR_TYPE_PRIMVAR:
primvarInterpolationIndex = self.exportedAttrsModel.index(row,
ExportedAttributesModel.PRIMVAR_INTERPOLATION_COLUMN)
self.exportedAttrsView.openPersistentEditor(primvarInterpolationIndex)
# Only open the double-to-single precision editor if the Maya
# attribute is double-based.
mayaAttrNameIndex = self.exportedAttrsModel.index(row,
ExportedAttributesModel.MAYA_ATTR_NAME_COLUMN)
mayaAttrName = self.exportedAttrsModel.data(mayaAttrNameIndex)
if _ShouldEnableDoublePrecisionEditor(mayaAttrName):
doublePrecisionIndex = self.exportedAttrsModel.index(row,
ExportedAttributesModel.DOUBLE_PRECISION_COLUMN)
self.exportedAttrsView.openPersistentEditor(doublePrecisionIndex)
self.exportedAttrsView.resizeColumnsToContents()
# Collect the attributes common to all selected nodes.
cmdOptions = {'read': True}
if self.userDefinedCheckBox.isChecked():
cmdOptions['userDefined'] = True
commonAttrNames = set(cmds.listAttr(selectedNodeNames[0], **cmdOptions) or [])
for selectedNodeName in selectedNodeNames[1:]:
attrNames = set(cmds.listAttr(selectedNodeName, **cmdOptions) or [])
commonAttrNames.intersection_update(attrNames)
# Subtract out reserved attribute names and attributes already being
# exported by ANY node.
commonAttrNames -= RESERVED_ATTRIBUTES
commonAttrNames -= allExportedAttributeNames
self.addAttrsModel.setStringList(sorted(list(commonAttrNames)))
