def __init__(self, table_view=None, *args):
super(MrDataTable2, self).__init__(*args)
if table_view is None:
table_view = QtWidgets.QTableView(self)
self.table_view = table_view
self.table_view.keyPressEvent = self.keyPressEvent
self.table_view.keyReleaseEvent = self.keyReleaseEvent
self.table_model = MrTableModel(self.table_view)
self.table_view.setModel(self.table_model)
self.selection_model = self.table_view.selectionModel()
""":type: QtGui.QItemSelectionModel"""
self.selection_model.selectionChanged.connect(self._selection_changed)
self._old_row = -1
self._old_column = -1
self._enter_down = False
self.data_changed = self.table_model.data_changed
self.data_changed.connect(self._data_changed)
self.copy = MrSignal()
self.paste = MrSignal()
self.show()
def __init__(self):
vtkCameraManipulator.__init__(self)
self.picked_data = None
self.box_picker = vtk.vtkExtractSelectedFrustum()
self._start_position = [0, 0]
self._end_position = [0, 0]
self._pixel_array = vtk.vtkUnsignedCharArray()
self.ex = vtk.vtkExtractSelection()
self.selection_node = vtk.vtkSelectionNode()
self.selection_node.SetContentType(vtk.vtkSelectionNode.THRESHOLDS)
self.ex_selection = vtk.vtkSelection()
self.ex_selection.AddNode(self.selection_node)
self.ex.SetInputConnection(0, self.box_picker.GetOutputPort())
self.ex.SetInputData(1, self.ex_selection)
self._down_pos = None
self._up_pos = None
self.iren = None
self.ren_win = None
self.ren_win_size = None
self.data_picked = MrSignal()
self.done_picking = MrSignal()
self._picking_active = False
# self.vtk_graphics = VTKGraphics.instance()
from .picking_manager import PickingManager
self.picking_manager = PickingManager.instance()
def __init__(self, *args, **kwargs):
super().__init__(*args)
self._scroll_factor = 1.
self._enter_down = True
self.undo = MrSignal()
self.redo = MrSignal()
def __init__(self):
self._database_exe = None
self._application_name = 'N/A'
self._user_manual = None
self._email_recipient = None
self._long_name = None
self._date_created = None
self._date_modified = None
self._author = None
self._description = None
self._icon = None
self._file_extension = None
self._macro_extension = None
tmp = scriptinfo()
self._executable = tmp['name']
self._executable_directory = tmp['dir']
self._frozen = tmp['frozen']
self._directory = None
self._filename = ''
self._dpi = 0
self._app_data_path = None
self._settings_file = None
self._default_settings_file = None
self._release_file = None
self._beta_file = None
self._app = None
""":type: PyQt5.QtWidgets.QApplication.QApplication"""
self._main_window = None
""":type: PyQt5.QtWidgets.QMainWindow.QMainWindow"""
self._main_data = None
self.dispatcher = CommandDispatcher()
##############################################################################
self._msgs = []
self.message = MrSignal()
self.msg = MrSignal()
self._read_config()
self.picking_manager = None
""":type: fem.gui.vtk_widget.vtk_graphics.picking.PickingManager"""
def __init__(self, *args):
super(TableDataModel, self).__init__(*args)
# self._headers = None
self._data = None
self._editable_columns = None
""":type: set"""
self.set_data = MrSignal()
def __init__(self, *args):
super(DockDataTableModel, self).__init__(*args)
self._headers = None
self.model_data = None
self.editable_columns = set()
self.set_data = MrSignal()
self._count = 0
def __init__(self, tab_name, parent=None):
super(BasicTabWidget, self).__init__(parent)
self.tab_name = tab_name
self.dispatcher = _CommandDispatcher(tab_name, self)
self.tables = {}
self.data_changed = MrSignal()
def __init__(self):
super(MainData, self).__init__()
self.data = OrderedDict()
self.data_keys = []
self.interface1 = MainDataInterface1(self)
self.interface2 = MainDataInterface2(self)
self.data_changed = MrSignal()
def __init__(self, data_id=None):
self.data = {}
""":type: dict[DummyTableData]"""
self._headers = list(self.DefaultDataType.headers)
self._data_id = data_id
self.list_changed = MrSignal()
self._ids = []
def __init__(self, parent=None, main_data=None, *args):
super(RecursiveTable, self).__init__(parent, *args)
# FIXME: main_data should be renamed to table_data since it is confusing with app main_data
self.main_data = main_data
self.config = Configuration(self.main_data.get_id())
self.table = EmptyTable(self)
self.dispatcher = self.config.dispatcher
self.dispatcher.main_window = self
self.dispatcher.table = self.table
self.dispatcher.get_model = self.main_data
self.Actions = self.config.Actions
self.Commands = self.config.Commands
self.Actions.set_main_data(self.main_data)
self.Commands.set_main_window(self)
self.table.pushButton_add.clicked.connect(self._add)
self.table.pushButton_insert.clicked.connect(self._insert)
self.table.pushButton_delete.clicked.connect(self._delete)
self.table.pushButton_up.clicked.connect(self._up)
self.table.pushButton_down.clicked.connect(self._down)
self.table_model = TableDataModel()
self.table.set_model(self.table_model)
self.table.set_data.connect(self._set_data)
self.table.paste.connect(self._paste)
self.table.set_rows.connect(self._set_rows)
self.table.undo.connect(self._undo)
self.table.redo.connect(self._redo)
self.table_model.setup_data(self.main_data)
self._splitter = QtWidgets.QSplitter(QtCore.Qt.Horizontal)
self._splitter.addWidget(self.table)
self.setLayout(QtWidgets.QHBoxLayout())
self.layout().addWidget(self._splitter)
self.table.selection_changed.connect(self._selection_changed)
self.table.data_changed.connect(self._data_changed)
self.subtable = None
""":type: RecursiveTable"""
self.data_changed = MrSignal()
def __init__(self, *args):
super(TableModel, self).__init__(*args)
self.headers = None
self._data = None
self._get_data = None
self._set_data = None
self.editable_columns = set()
self.data_changed = MrSignal()
self.set_data_signal = MrSignal()
def __init__(self):
self.groups = OrderedDict()
""":type: OrderedDict[FemGroup]"""
self.data_changed = MrSignal()
self._all_groups = FemGroup()
self._default_group = FemGroup()
self._default_group.group_name = 'Default'
self._default_group.data_changed.connect(self._data_changed)
self.groups['Default'] = self._default_group
def __init__(self, data_id=None):
self.data = []
""":type: list[DummyTableData]"""
self._headers = list(self.DefaultDataType.headers)
self._formats = list(self.DefaultDataType.formats)
self._setters = list(self.DefaultDataType.setters)
self._data_id = data_id
self.list_changed = MrSignal()
self._ids = []
def __init__(self, data_id=None):
super(TableNumpyDataList, self).__init__(data_id)
self.dtype = self.DefaultDataType.dtype
self.blank_data = np.zeros(1, dtype=self.dtype)
self.data = np.zeros(0, dtype=self.dtype)
self._headers = list(
self.data.dtype.names)[:self.DefaultDataType.columns()]
self.list_changed = MrSignal()
def __init__(self):
vtkCameraManipulator.__init__(self)
self.cell_picker = CellPicker()
self.hovered_data = None
self.visible_filter = None
self.pickable_types = None
self.picked_id = -1
self.vtk_graphics = VTKGraphics.instance()
self.key_down = MrSignal()
def __init__(self, data_id=None):
self._data_id = data_id
self.dtype = self.DefaultDataType.dtype
self.blank_data = np.zeros(1, dtype=self.dtype)
self.data = np.zeros(0, dtype=self.dtype)
self._headers = list(
self.data.dtype.names)[:self.DefaultDataType.columns()]
self._ids = []
self.list_changed = MrSignal()
def __init__(self, dock_name='BasicDockWidget'):
super(BasicDockWidget, self).__init__()
self.dock_name = dock_name
self.setWindowTitle(dock_name)
self.dispatcher = _CommandDispatcher(dock_name, self)
self.widget = None
self.show_dock = MrSignal()
self.data_changed = MrSignal()
""":type: MrSignal"""
def __init__(self, *args):
super(TableDataWidget, self).__init__(*args)
self.ui = Ui_Form()
self.ui.setupUi(self)
self.tableView_list = DataTable.wrap_obj(self.ui.tableView_list)
self.tableView_data = DataTable.wrap_obj(self.ui.tableView_data)
self.tableView_list.set_editable_columns([0, 1])
self.tableView_data.set_editable_columns([i for i in range(100)])
self.ui.pushButton_add.clicked.connect(self._add)
self.ui.pushButton_insert.clicked.connect(self._insert)
self.ui.pushButton_delete.clicked.connect(self._delete)
self.ui.pushButton_up.clicked.connect(self._up)
self.ui.pushButton_down.clicked.connect(self._down)
self.ui.pushButton_open.clicked.connect(self._open)
self.main_data = MainData()
""":type: fem.utilities.table_data_widget.model.MainData"""
self.config = Configuration()
self.tableView_list.setup_data(self.main_data.headers_1, self.main_data.interface1)
self.tableView_data.setup_data(self.main_data.headers_2, self.main_data.interface2)
self.tableView_list.selection_changed.connect(self._selection_changed)
self.tableView_list.set_data_signal.connect(self._set_data_1)
self.tableView_data.set_data_signal.connect(self._set_data_2)
self.tableView_list.paste.connect(self._paste_1)
self.tableView_data.paste.connect(self._paste_2)
self.tableView_list.undo.connect(self._undo)
self.tableView_list.redo.connect(self._redo)
self.tableView_data.undo.connect(self._undo)
self.tableView_data.redo.connect(self._redo)
self.data_changed = MrSignal()
self.main_data.data_changed.connect(self._data_changed)
def __init__(self):
vtkCameraManipulator.__init__(self)
self._start_position = [0, 0]
self._end_position = [0, 0]
self._pixel_array = vtk.vtkUnsignedCharArray()
self._left_button_down = False
self._ctrl_left_button_down = False
self._right_button_down = False
self._middle_button_down = False
self._down_pos = None
self._up_pos = None
self._point_list = []
self.renderer = None
self.iren = None
#self.reset_polygon()
self._points = 0
self.polygon = vtk.vtkPolygon()
self.poly_data = vtk.vtkPolyData()
self.poly_points = vtk.vtkPoints()
self.poly_data.SetPoints(self.poly_points)
self.cell_array = vtk.vtkCellArray()
self.cell_array.InsertNextCell(self.polygon)
self.cell_array.Squeeze()
self.poly_data.SetPolys(self.cell_array)
self.done_picking = MrSignal()
self._picking_active = False
self.poly_pick_filter = PolyPickFilter()
self.poly_pick_filter.set_poly_pick_data(self.poly_data)
self.vtk_graphics = VTKGraphics.instance()
from .picking_manager import PickingManager
self.picking_manager = PickingManager.instance()
def init(self):
self.table_model = MrTableModel(self)
self.setModel(self.table_model)
self.selection_model = self.selectionModel()
""":type: QtGui.QItemSelectionModel"""
self.selection_model.selectionChanged.connect(self._selection_changed)
self._old_row = -1
self._old_column = -1
self._enter_down = False
self.data_changed = self.table_model.data_changed
self.data_changed.connect(self._data_changed)
self.copy = MrSignal()
self.paste = MrSignal()
def __init__(self):
from fem.gui.vtk_widget.vtk_graphics import VTKGraphics
self.vtk_graphics = VTKGraphics.instance()
""":type: fem.gui.vtk_widget.vtk_graphics.VTKGraphics"""
self.picked_selection = self.vtk_graphics.picked_selection
""":type: fem.gui.vtk_widget.vtk_graphics.picked.PickedSelection"""
self.default_single_picker = DefaultSinglePicker(self)
self._single_pickers = [self.default_single_picker]
""":type: list[SinglePicker]"""
self.single_picker = self.default_single_picker
self.picking_option = 1
self._registered_selection = None
""":type: fem.gui.vtk_widget.vtk_graphics.picked.PickedSelection"""
self.picking_finished = MrSignal()
def __init__(self, parent, data, options_data, dialog_title):
"""
:param parent: QtWidgets.QLineEdit to whom the delegate belongs to
:type parent: QtWidgets.QLineEdit
:param data: AbstractData to whom the delegate sends _main_data to
:type data: AbstractData
"""
AbstractLineEditDelegate.__init__(self, parent, data)
self.setObjectName(str(parent.objectName()) + "_delegate")
self._dialog_title = dialog_title
self._dialog = None
self._options_data = options_data
self.update_value = MrSignal()
self._return_list = False
if hasattr(self._options_data, 'return_data_list'):
if self._options_data.return_data_list is True:
self._return_list = True
def __init__(self, dock_name='BasicDockWidget'):
super(BasicDockWidget, self).__init__()
self.dock_name = dock_name
self.setWindowTitle(dock_name)
self.dispatcher = _CommandDispatcher(dock_name, self)
# self.dispatcher.set_prefix(dock_name)
self.tab_widget = None
""":type: BasicTabWidget"""
# self.tab_widget.dispatcher.set_prefix(tab_prefix)
# self.tab_widget.dispatcher.register_parent_dispatcher(self.dispatcher, self.dock_name)
# self.setWidget(self.tab_widget)
self.show_dock = MrSignal()
self.data_changed = MrSignal()
""":type: MrSignal"""
def __init__(self, parent=None, dispatcher_id=None, id_1='Table1', id_2='Table2'):
super(MultiTable, self).__init__(parent)
class _Table1(BasicTable):
MainData = self.MainData_1
main_data = self.main_data_1
class _Table2(BasicTable):
MainData = self.MainData_2
main_data = self.main_data_2
self.table_1 = _Table1(self)
self.table_1.dispatcher.dispatcher_id = id_1
self.table_2 = _Table2(self)
self.table_2.dispatcher.dispatcher_id = id_2
self._splitter = QtWidgets.QSplitter(QtCore.Qt.Horizontal)
self._splitter.addWidget(self.table_1)
self._splitter.addWidget(self.table_2)
self._layout = QtWidgets.QHBoxLayout(self)
self.setLayout(self._layout)
self._layout.addWidget(self._splitter)
self.table_1.table_1.row_changed.connect(self._row_changed)
self.dispatcher = _CommandDispatcher(self)
self.dispatcher.dispatcher_id = dispatcher_id
self.dispatcher.add_child(self.table_1.dispatcher)
self.dispatcher.add_child(self.table_2.dispatcher)
self.request_focus = MrSignal()
self.data = {}
""":type: dict[str, TableDataList]"""
def __init__(self, *args, **kwargs):
super().__init__(*args)
self._scroll_factor = 1.
self._enter_down = False
self._shift_down = False
self._ctrl_down = False
self.undo = MrSignal()
self.redo = MrSignal()
self._model = self.TableModel()
self.setModel(self._model)
self.selection_model = self.selectionModel()
""":type: QtGui.QItemSelectionModel"""
self.selection_model.selectionChanged.connect(self._selection_changed)
self.selection_changed = MrSignal()
self.row_changed = MrSignal()
self.column_changed = MrSignal()
self._old_row = -1
self._old_column = -1
def __init__(self):
vtkPVInteractorStyle.__init__(self)
self._rotate = vtkPVTrackballRotate()
self._pan = vtkPVTrackballPan()
self._zoom = vtkPVTrackballZoom()
self._hover = None
""":type: gui.vtk_widget.vtk_graphics.interactor_styles.hovered_interactor_style.HoveredInteractorStyle"""
self._pan.GUIHelper = vtkCameraManipulatorGUIHelper()
self._buttons_pressed = set()
# these need to be implemented
#selection_data.translation_factor_changed.connect(self.set_translation_factor)
#selection_data.rotation_factor_changed.connect(self.set_rotation_factor)
#selection_data.zoom_scale_factor_changed.connect(self.set_zoom_scale_factor)
self._box_picker = None
""":type: gui.vtk_widget.vtk_graphics.picking.BoxPicker"""
self._poly_picker = None
""":type: gui.vtk_widget.vtk_graphics.picking.PolyPicker"""
#selection_data.box_picker_activate.connect(self.box_picker_activate)
#selection_data.poly_picker_activate.connect(self.poly_picker_activate)
self._active_picker = None
self.vtk_graphics = None
""":type: VTKGRaphics"""
self.picking_manager = None
""":type: PickingManager"""
self.zoom_changed = MrSignal()
def __init__(self, main_window):
super(GroupsDock, self).__init__(main_window)
self.main_window = main_window
self.ui = Ui_DockWidget()
self.ui.setupUi(self)
self._groups_table_model = GroupsTableModel()
self.ui.tableView_groups.setModel(self._groups_table_model)
self._groups_selection_model = self.ui.tableView_groups.selectionModel(
)
""":type: QtGui.QItemSelectionModel"""
self._groups_selection_model.selectionChanged.connect(
self._groups_selection_changed)
self.row_changed = MrSignal()
self.column_changed = MrSignal()
self.selection_changed = MrSignal()
self._old_row = -1
self._old_column = -1
self.ui.pushButton_add_group.clicked.connect(self.add_group)
self.ui.pushButton_remove_group.clicked.connect(self.remove_group)
self.ui.pushButton_add_member.clicked.connect(self.add_members)
self.ui.pushButton_remove_member.clicked.connect(self.remove_members)
self._selection = PickedSelection()
self._selection.data_changed.connect(self._picked_data_changed)
self.setWindowTitle('Plot/Erase Groups')
class Configuration(object):
config_file = config_file
_major_version = 0
_minor_version = 0
_micro_version = 0
_other_version = 'alpha'
def __init__(self):
self._database_exe = None
self._application_name = 'N/A'
self._user_manual = None
self._email_recipient = None
self._long_name = None
self._date_created = None
self._date_modified = None
self._author = None
self._description = None
self._icon = None
self._file_extension = None
self._macro_extension = None
tmp = scriptinfo()
self._executable = tmp['name']
self._executable_directory = tmp['dir']
self._frozen = tmp['frozen']
self._directory = None
self._filename = ''
self._dpi = 0
self._app_data_path = None
self._settings_file = None
self._default_settings_file = None
self._release_file = None
self._beta_file = None
self._app = None
""":type: PyQt5.QtWidgets.QApplication.QApplication"""
self._main_window = None
""":type: PyQt5.QtWidgets.QMainWindow.QMainWindow"""
self._main_data = None
self.dispatcher = CommandDispatcher()
##############################################################################
self._msgs = []
self.message = MrSignal()
self.msg = MrSignal()
self._read_config()
self.picking_manager = None
""":type: fem.gui.vtk_widget.vtk_graphics.picking.PickingManager"""
def register_picking_manager(self, picking_manager):
self.picking_manager = picking_manager
def database_exe(self):
return self._database_exe
def application_name(self):
return self._application_name
def major_version(self):
return self._major_version
def minor_version(self):
return self._minor_version
def micro_version(self):
return self._micro_version
def other_version(self):
return self._other_version
def user_manual(self):
return self._user_manual
def email_recipient(self):
return self._email_recipient
def long_name(self):
return self._long_name
def date_created(self):
return self._date_created
def date_modified(self):
return self._date_modified
def author(self):
return self._author
def description(self):
return self._description
def icon(self):
return self._icon
def file_extension(self):
return self._file_extension
def macro_extension(self):
return self._macro_extension
def executable(self):
return self._executable
def executable_directory(self):
return self._executable_directory
def frozen(self):
return self._frozen
def directory(self):
# type: () -> str
if self._directory is None:
return self.home_directory()
return self._directory
def set_directory(self, directory):
# type: (str) -> None
directory = os.path.dirname(os.path.realpath(str(directory)))
assert os.path.isdir(directory)
self._directory = directory
def filename(self):
# type: () -> str
return self._filename
def set_filename(self, filename):
# type: (str) -> None
self.set_directory(filename)
self._filename = filename
def dpi(self):
return self._dpi
def app_data_path(self):
return self._app_data_path
def settings_file(self):
return self._settings_file
def default_settings_file(self):
if os.path.isfile(self._default_settings_file):
return self._default_settings_file
return None
def release_file(self):
return self._release_file
def beta_file(self):
return self._beta_file
def app(self):
if self._app is None:
self._app = QtWidgets.QApplication([])
w = QtWidgets.QWidget()
self._dpi = w.logicalDpiX()
if self._dpi != 96:
font = self._app.font()
font.setPixelSize(13)
self._app.setFont(font)
return self._app
def set_icon(self):
self.app().setWindowIcon(QtGui.QIcon(self._icon))
def main_window(self):
return self._main_window
def register_main_window(self, mw):
self._main_window = mw
try:
self.dispatcher.register_main_window(mw)
except AttributeError:
pass
def main_data(self):
return self._main_data
def register_main_data(self, md):
self._main_data = md
def version(self):
if self._other_version == '':
return self._major_version, self._minor_version, self._micro_version
else:
return self._major_version, self._minor_version, self._micro_version, self._other_version
def application_version(self):
return ('%d.%d.%d %s' %
(self._major_version, self._minor_version, self._micro_version,
self._other_version)).strip()
def program_name(self):
# type: () -> str
return '%s %s' % (self._application_name, self.application_version())
def application_info(self):
# _data_roles = OrderedDict()
data = {}
data['Application Name'] = self._application_name
data['Application Version'] = self.application_version()
ts = timestamp().split(' ')
data['Date'] = ts[0]
data['Time'] = ts[1]
data['User ID'] = self.user_id()
return data
def window_title(self):
# type: () -> str
if self._filename is None:
filename = "*"
else:
filename = self._filename
if not self.dispatcher.undo_stack.isClean():
filename += "*"
return "%s - [%s]" % (self.program_name(), filename)
def user_id(self):
return getpass.getuser()
@staticmethod
def home_directory():
# type: () -> str
return os.path.expanduser('~')
def view_label(self):
# type: () -> str
if self._filename is None:
filename = '*'
else:
filename = self._filename
return '%s\n%s\n%s' % (self.program_name(), filename, timestamp())
def about(self):
about_txt = """
Program Name: %s
Version: %s
Description: %s
Author: %s
Date Created: %s
Date Modified: %s
""" % (self._long_name, self.application_version(), self._description,
self._author, self._date_created, self._date_modified)
return about_txt
@staticmethod
def file_in_use(filename):
if os.path.exists(filename):
# noinspection PyBroadException
try:
os.rename(filename, filename + '_')
os.rename(filename + '_', filename)
return False
except Exception:
return True
return False
def info_message(self, msg):
# type: (str) -> None
self.msg.emit('Info: %s' % msg)
def push_error(self, msg):
self._msgs.append('Error: %s' % msg)
def push_info(self, msg):
self._msgs.append('Info: %s' % msg)
def flush_msgs(self):
for msg in self._msgs:
self.msg.emit(msg)
del self._msgs[:]
def clear_msgs(self):
del self._msgs[:]
def error_message(self, msg):
# type: (str) -> None
self.msg.emit('Error: %s' % msg)
def _read_config(self):
config_file = self.config_file
if config_file is None:
return
# config_file = 'configuration.%s.%d.%d.%d.json' % (
# self.config_app_name, self._major_version, self._minor_version, self._micro_version
# )
# config_file = os.path.join(self.config_directory, config_file)
with open(config_file, 'r') as f:
data = json.load(f)
application = data['application']
self._author = application['author']
self._date_created = application['date_created']
self._date_modified = application['date_modified']
self._description = application['description']
self._long_name = application['long_name']
self._application_name = application['application_name']
version = application['version']
major = version['major']
minor = version['minor']
micro = version['micro']
other = version['other']
files = data['files']
self._release_file = files['release_file']
self._beta_file = files['beta_file']
self._icon = files['icon']
self._user_manual = files['user_manual']
# self._default_settings_file = files['default_settings_file']
feedback = data['feedback']
self._email_recipient = feedback['email_recipient']
extensions = data['extensions']
self._file_extension = extensions['file_extension']
self._macro_extension = extensions['macro_extension']
# self._database_exe = data['plugins']['punch_database']
self._app_data_path = os.getenv(
'APPDATA') + r'\StressApps\%s' % self._application_name.lower()
assert (major, minor, micro,
other) == (self._major_version, self._minor_version,
self._micro_version, self._other_version)
self.set_icon()
return data
class TableDataModel(QtCore.QAbstractTableModel):
def __init__(self, *args):
super(TableDataModel, self).__init__(*args)
# self._headers = None
self._data = None
self._editable_columns = None
""":type: set"""
self.set_data = MrSignal()
def setup_data(self, data):
try:
assert isinstance(data, TableDataList)
except AssertionError:
print(data.__class__)
raise
self._data = data
# self._headers = list(data.headers)
self._editable_columns = self._data.editable_columns()
self.update_all()
def headerData(self, section, orientation, role=QtCore.Qt.DisplayRole):
if self._data is not None and role == QtCore.Qt.DisplayRole:
if orientation == QtCore.Qt.Horizontal:
return self._data.headers[section]
else:
return section + 1
return None
def rowCount(self, index=QtCore.QModelIndex()):
try:
return len(self._data)
except TypeError:
return 0
def columnCount(self, index=QtCore.QModelIndex()):
try:
return len(self._data.headers)
except (TypeError, AttributeError):
return 0
def flags(self, index):
if int(index.column()) in self._editable_columns:
return QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEditable
else:
return QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable
def data(self, index, role=QtCore.Qt.DisplayRole):
if self._data is None or not index.isValid():
return None
if role == QtCore.Qt.EditRole:
row = index.row()
col = index.column()
data_ = self._data[row]
try:
data = data_.edit_role(col)
except AttributeError:
data = data_[col]
except TypeError:
data = None
if data is None:
return ''
return str(data)
elif role == QtCore.Qt.DisplayRole:
row = index.row()
col = index.column()
data_ = self._data[row]
try:
data = data_[col]
except (TypeError, IndexError):
data = None
if data is None:
return ''
if isinstance(data, list) and len(data) > 0 and isinstance(
data[0], float):
return str([round(i, 6) for i in data])
return str(data)
return None
def setData(self, index, value, role=QtCore.Qt.DisplayRole):
if self._data is None:
return False
row = index.row()
col = index.column()
self.set_data.emit((row, col), str(value), role)
return True
def update_all(self):
try:
self._editable_columns = self._data.editable_columns()
except AttributeError:
pass
self.layoutChanged.emit()
top_left = self.index(0, 0)
bot_right = self.index(self.rowCount() - 1, self.columnCount() - 1)
self.dataChanged.emit(top_left, bot_right)
def __init__(self,
tree1,
tree2,
add_btn,
del_btn,
add_all=None,
remove_all=None):
self.data_added = MrSignal()
self.data_removed = MrSignal()
self.selection_changed = MrSignal()
if not isinstance(tree1, BasicTreeView):
tree1 = BasicTreeView.wrap_obj(tree1)
if not isinstance(tree2, BasicTreeView):
tree2 = BasicTreeView.wrap_obj(tree2)
self._tree1 = tree1
self._tree2 = tree2
self._tree1.sorting_changed.connect(self.update_trees)
self._tree2.sorting_changed.connect(self.update_trees)
self.pushButton_add = add_btn
""":type: QtGui.QPushButton"""
self.pushButton_delete = del_btn
""":type: QtGui.QPushButton"""
self.pushButton_add_all = add_all
""":type: QtGui.QPushButton"""
self.pushButton_remove_all = remove_all
""":type: QtGui.QPushButton"""
self.pushButton_add_clicked = MrSignal()
self.pushButton_delete_clicked = MrSignal()
self.pushButton_add_all_clicked = MrSignal()
self.pushButton_remove_all_clicked = MrSignal()
self.pushButton_add.clicked.connect(self.pushButton_add_clicked.emit)
self.pushButton_delete.clicked.connect(
self.pushButton_delete_clicked.emit)
if self.pushButton_add_all:
self.pushButton_add_all.clicked.connect(
self.pushButton_add_all_clicked.emit)
if self.pushButton_remove_all:
self.pushButton_remove_all.clicked.connect(
self.pushButton_remove_all_clicked.emit)
self.pushButton_add_clicked.connect(self._add_btn_clicked)
self.pushButton_delete_clicked.connect(self._remove_btn_clicked)
self.pushButton_add_all_clicked.connect(self.add_all)
self.pushButton_remove_all_clicked.connect(self.remove_all)
self._data = OrderedDict()
