def __init__(self, parent = None):
QTableWidget.__init__(self, parent)
# init
# ------------------------------------------------
#FIXME: move this somewhere else maybe?
self.tmpSelectedItems = []
#FIXME: what does this do? put a comment, why 30,30?
self._sigmaList = None
self._featureGroupMapping = None # Schema: [ (groupName1, [entry, entry...]),
# (groupName2, [entry, entry...]) ]
#layout
# ------------------------------------------------
self.setCornerButtonEnabled(False)
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.setSelectionMode(QAbstractItemView.NoSelection)
self.setShowGrid(False)
self.viewport().installEventFilter(self)
self.setMouseTracking(1)
self.verticalHeader().setHighlightSections(False)
self.verticalHeader().setSectionsClickable(True)
self.horizontalHeader().setHighlightSections(False)
self.horizontalHeader().setSectionsClickable(True)
self.horizontalHeader().setMouseTracking(True)
self.horizontalHeader().installEventFilter(self)
self.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.verticalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.itemSelectionChanged.connect(self._tableItemSelectionChanged)
self.cellDoubleClicked.connect(self._featureTableItemDoubleClicked)
self.verticalHeader().sectionClicked.connect(self._expandOrCollapseVHeader)
def __init__(self, parent=None, featureGroups=[], sigmas=[], computeIn2d=[], window_size=3.5):
"""
Args:
featureGroups: A list with schema: [ (groupName1, [entry, entry...]),
(groupName2, [entry, entry...]), ... ]
sigmas: List of sigmas (applies to all features)
computeIn2d: List of booleans to indicate which sigma column should be computed in 2d (rather than 3d)
"""
QTableWidget.__init__(self, parent)
self.setCornerButtonEnabled(False)
self.setEditTriggers(QAbstractItemView.AllEditTriggers)
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.setShowGrid(False)
self.setMouseTracking(1)
self.verticalHeader().setHighlightSections(False)
self.verticalHeader().setSectionsClickable(True)
self.verticalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.verticalHeader().sectionPressed.disconnect()
self.verticalHeader().sectionClicked.connect(self._expandOrCollapseVHeader)
self.horizontalHeader().setHighlightSections(False)
self.horizontalHeader().setSectionsClickable(False)
# self.horizontalHeader().installEventFilter(self)
self.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.itemSelectionChanged.connect(self._itemSelectionChanged)
self.cellChanged.connect(self._cellChanged)
if featureGroups or sigmas or computeIn2d:
self.setup(featureGroups, sigmas, computeIn2d, window_size)
def __init__(self, parent, configuration):
QTableWidget.__init__(self, 5, 1, parent)
self._configuration = configuration
self._manual_change = True
self.setVerticalHeaderLabels(
["Duration (cycles)", "Duration (ms)", "Cycles / ms",
'RAM access time', 'Execution Time Model'])
self.horizontalHeader().setStretchLastSection(True)
self.horizontalHeader().hide()
self.setItem(0, 0, QTableWidgetItem(str(configuration.duration)))
self.setItem(1, 0, QTableWidgetItem(str(
float(configuration.duration) / configuration.cycles_per_ms)))
self.setItem(2, 0, QTableWidgetItem(str(configuration.cycles_per_ms)))
self.setItem(
3, 0, QTableWidgetItem(str(configuration.memory_access_time)))
item = QComboBox(self)
selected = 0
for i, (etm_name, etm_code) in \
enumerate(execution_time_model_names.items()):
item.addItem(etm_name)
if etm_code == configuration.etm:
selected = i
item.setCurrentIndex(selected)
self.setCellWidget(4, 0, item)
def activation_handler(x):
configuration.etm = execution_time_model_names[str(x)]
configuration.conf_changed()
item.activated['QString'].connect(activation_handler)
# self._update_observe_window()
self.cellChanged.connect(self._cell_changed)
def __init__(self, parent, result):
QTableWidget.__init__(self, len(result.model.logs), 3, parent=parent)
self.setWindowTitle("Logs")
self.setHorizontalHeaderLabels(["Date (cycles)", "Date (ms)", "Message"])
self.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.horizontalHeader().setStretchLastSection(True)
self.horizontalHeader().setMinimumSectionSize(60)
self.verticalHeader().hide()
self._sim = result.model
self.result = result
self.update()
def __init__(self, parent, result):
QTableWidget.__init__(
self, len(result.model.processors) + 1, 3, parent)
self.result = result
self.setHorizontalHeaderLabels(["Total load", "Payload",
"System load", "Theoric min"])
self.setVerticalHeaderLabels(
[x.name for x in result.model.processors] + ["Average"])
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.update()
def __init__(self, *args, **kwargs):
QTableWidget.__init__(self, *args)
if 'tamanio' in kwargs:
self.tamanio = kwargs['tamanio']
font = QFont()
font.setPointSizeF(self.tamanio)
self.setFont(font)
if 'habilitarorden' in kwargs:
self.setSortingEnabled(kwargs['habilitarorden'])
else:
self.setSortingEnabled(True)
if 'enabled' in kwargs:
self.setEnabled(kwargs['enabled'])
def __init__(self, *args, **kwargs):
QTableWidget.__init__(self, *args)
if 'tamanio' in kwargs:
self.tamanio = kwargs['tamanio']
font = QFont()
font.setPointSizeF(self.tamanio)
self.setFont(font)
if 'habilitarorden' in kwargs:
self.setSortingEnabled(kwargs['habilitarorden'])
else:
self.setSortingEnabled(True)
# self.itemClicked.connect(self.handleItemClicked)
self.setEditTriggers(QAbstractItemView.AllEditTriggers)#para que se pueda editar el contenido con solo un click
def __init__(self, *args, **kwargs):
stock_prices_stream = kwargs.pop('stock_prices_stream')
QTableWidget.__init__(self, *args, **kwargs)
self.setRowCount(0)
self.setColumnCount(4)
self.setHorizontalHeaderLabels(
['Symbol', 'Name', 'Buy Price', 'Sell Price'])
self.setColumnWidth(0, 50)
self.setColumnWidth(1, 200)
self.setColumnWidth(2, 100)
self.setColumnWidth(3, 100)
self.horizontalHeader().setStretchLastSection(True)
self.setSortingEnabled(True)
stock_prices_stream.subscribe(self._create_or_update_stock_row)
def __init__(
self,
gui,
enabled=True,
cell_edited_callback=None,
selection_changed_callback=None,
row_deleted_callback=None,
minimum_rows: int = 0,
):
"""
Initializes table.
@param gui: GUI
@param cell_edited_callback: Set this to make cells editable
@param selection_changed_callback: Used to inform the GUI that another row was selected
@param row_deleted_callback: Set this to make rows deletable
@param minimum_rows: Minimum number of rows (no further rows can be deleted)
"""
QTableWidget.__init__(self)
Debug(self, ": Init")
self.gui = gui
self._enabled = enabled
self._cell_edited_callback = cell_edited_callback
self._selection_changed_callback = selection_changed_callback
self._row_deleted_callback = row_deleted_callback
self._minimum_rows = minimum_rows
self._prefix = None
self._types = None
self._options = None
if self._cell_edited_callback is not None:
self.itemChanged.connect(self.on_numerical_cell_edited)
self.cellChanged.connect(self.on_cell_changed)
if self._selection_changed_callback is not None:
self.selectionModel().selectionChanged.connect(
self.on_selection_changed)
self.set_style(border_color="black", border_width=1)
self.setMinimumHeight(self.MinimumHeight)
self.setAlternatingRowColors(True)
self.setSelectionMode(QAbstractItemView.SingleSelection)
self.setSelectionBehavior(QAbstractItemView.SelectItems)
self.setFocusPolicy(Qt.StrongFocus)
def __init__(self, result, field, metrics=('min', 'avg', 'max', 'sum'),
parent=None, map_=lambda x: x):
QTableWidget.__init__(self, len(result.model.task_list),
1 + len(metrics), parent)
self.result = result
self.field = field
self.metrics = metrics
self.map_ = map_
self.setHorizontalHeaderLabels(['Task'] + metrics)
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.verticalHeader().hide()
self.update()
def __init__(self, parent, item_list, use_icons=False):
QTableWidget.__init__(self, len(item_list), 1, parent)
self.itemSelectionChanged.connect(self.onSelection)
self.setAlternatingRowColors(True)
self.setSelectionBehavior(1) # Select Rows
#self.setHorizontalHeaderLabels(["Title", "Address"])
#self.horizontalHeader().setDefaultSectionSize(240)
self.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
#self.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.horizontalHeader().setHidden(True)
self.verticalHeader().setHidden(True)
self.use_icons = use_icons
self.data_changed = False
self.data = item_list[:]
self.setMyData()
def __init__(self, parent, configuration):
QTableWidget.__init__(self, len(configuration.proc_info_list), 7,
parent)
self._configuration = configuration
self._manual_change = True
self.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.horizontalHeader().setStretchLastSection(True)
self._header = [
'id', 'Name', 'CS overhead', 'CL overhead', 'Caches',
'Cycles / mem access', 'Speed'
]
self.setVerticalHeaderLabels([""])
self.verticalHeader().hide()
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.refresh_table()
def __init__(self):
QTableWidget.__init__(self)
self.insertColumn(0)
self.insertColumn(1)
self.setHorizontalHeaderLabels(['Parameter', 'Value'])
self.horizontalHeader().setStretchLastSection(True)
self.horizontalHeader().setMinimumSectionSize(100)
self.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
self.horizontalHeader().setSectionResizeMode(
0, QHeaderView.ResizeToContents)
self.horizontalHeader().setFixedHeight(25)
self.verticalHeader().hide()
# self.verticalScrollBar().setStyleSheet( " background-color: rgba(255, 255, 255, 0%) ")
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
def __init__(self, header, outComeCategory, units, currencyIndex):
QTableWidget.__init__(self)
self._CurrencyIndex = currencyIndex
self._header = header
self._units = units
self._category = outComeCategory
self.setColumnCount(len(self._header))
self.setHorizontalHeaderLabels(self._header)
self.setSortingEnabled(False)
self.setWordWrap(True)
self.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)
self.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
self.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeToContents)
self.horizontalHeader().setSectionResizeMode(3, QHeaderView.ResizeToContents)
self.horizontalHeader().setSectionResizeMode(4, QHeaderView.ResizeToContents)
self.horizontalHeader().setSectionResizeMode(5, QHeaderView.ResizeToContents)
def __init__(self, int_obj):
QTableWidget.__init__(self, int_obj)
#self.setSelectionMode(QAbstractItemView.NoSelection)
self.setShowGrid(False)
self.verticalHeader().setVisible(False)
self.horizontalHeader().setVisible(False)
self.setRowCount(1)
self.setColumnCount(4)
self.setColumnWidth(0, 20)
self.setColumnWidth(1, 100)
self.setColumnWidth(2, 65)
self.setColumnWidth(3, 30)
self.int_obj = int_obj
self.filter_list = []
def __init__(self, parent):
QTableWidget.__init__(self, parent)
HubListener.__init__(self)
self.setSortingEnabled(True)
self.setEditTriggers(QTableWidget.NoEditTriggers)
self.verticalHeader().hide()
self.verticalHeader().setDefaultSectionSize(10)
self.setColumnCount(2)
self.setHorizontalHeaderLabels(('Key', 'Value'))
self.setHorizontalScrollMode(QTableWidget.ScrollPerPixel)
self.horizontalHeader().setSectionResizeMode(0,
QHeaderView.Interactive)
self.horizontalHeader().setSectionResizeMode(
1, QHeaderView.ResizeToContents)
self.register_to_hub(Manager.hub)
def __init__(self, parent):
"""
:param parent:
:return:
"""
QTableWidget.__init__(self, parent)
self._myParent = parent
self._myColumnNameList = None
self._myColumnTypeList = None
self._editableList = list()
self._statusColName = 'Status'
return
def __init__(self, parameters={}):
QTableWidget.__init__(self)
self.insertColumn(0)
self.insertColumn(1)
self.setHorizontalHeaderLabels(['Parameter', 'Value'])
self.horizontalHeader().setStretchLastSection(True)
self.horizontalHeader().setMinimumSectionSize(100)
self.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
self.horizontalHeader().setSectionResizeMode(
0, QHeaderView.ResizeToContents)
self.horizontalHeader().setFixedHeight(25)
self.verticalHeader().hide()
self.setShowGrid(False)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.set_parameters(parameters)
def __init__(self, data, dark_mode, connected_networks=[], *args):
QTableWidget.__init__(self, *args)
horHeaders = ["Network", "Auth", "PSK", "Metered?", "Random MAC?"]
self.setColumnCount(len(horHeaders))
self.setHorizontalHeaderLabels(horHeaders)
self.horizontalHeader().setStretchLastSection(True)
self.dark_mode = dark_mode
self.data = data
self.connected_networks = connected_networks
self.set_data(self.data)
# self.resizeColumnsToContents()
self.setColumnWidth(0, 230)
self.setColumnWidth(1, 100)
self.setColumnWidth(2, 250)
self.setColumnWidth(3, 60)
self.setColumnWidth(4, 80)
def __init__(self, parent=None):
QTableWidget.__init__(self, parent)
self.myBrush = QBrush()
self.myPen = QPen()
self.pixmap = None
self.pixmapHandwriting = None
self.deviceDown = False
self.time = QTime()
self.lastPoints = [QPoint(), QPoint()]
self.boxesToDraw = []
self.data = []
self.convert_pix_meter = 0.0001534
self.initPixmaps()
self.setAutoFillBackground(True)
self.setCursor(Qt.BlankCursor)
self.time.start()
def __init__(self, parent, configuration, simulation_tab):
QTableWidget.__init__(self, 5, 2, parent)
self._header = ['Scheduler', 'Scheduler Path',
'Overhead schedule (cycles)',
'Overhead on activate (cycles)',
'Overhead on terminate (cycles)']
self._dict_header = {
'scheduler': 0,
'scheduler_path': 1,
'overhead_schedule': 2,
'overhead_activate': 3,
'overhead_terminate': 4
}
self._configuration = configuration
self._simulation_tab = simulation_tab
self.refresh_table()
self.cellChanged.connect(self._cell_changed)
self.cellActivated.connect(self._cell_activated)
def __init__(self, timing_table, channels, io_type):
QTableWidget.__init__(self)
self.channels = channels
self.setRowCount(len(channels))
self.setVerticalHeaderLabels(channels)
self.timing_table = timing_table
self.io_type = io_type
self.setShowGrid(False)
self.vertical_margin = 5
self.verticalHeader().setDefaultSectionSize(30 + self.vertical_margin)
self.setSelectionMode(self.NoSelection)
## self.verticalHeader().sectionDoubleClicked.connect(self.rename_channel)
self.label_width = timing_table.label_width
self.verticalHeader().setFixedWidth(self.label_width)
self.verticalHeader().setContextMenuPolicy(Qt.CustomContextMenu)
self.verticalHeader().customContextMenuRequested.connect(
self.row_context_menu)
self.timing_table.register(self)
self.hide_inactive = False
def __init__(self, score, player, *args):
QTableWidget.__init__(self, *args)
self.rows, self.columns = args
self.player = player
self.setShowGrid(True)
self.setCornerButtonEnabled(False)
self.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
self.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeToContents)
self.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeToContents)
self.setHorizontalHeaderLabels(['słowa', 'pkt.', 'suma'])
self.verticalHeader().setSectionResizeMode(QHeaderView.Fixed)
self.verticalScrollBar().rangeChanged.connect(self.set_to_max_value)
self.score = score
self.score.bind_to(self.submit_turn, player)
self.count = 0
self.resizeRowsToContents()
def __init__(self, parent, configuration):
QTableWidget.__init__(self, 0, 0, parent)
self._ignore_cell_changed = False
self.horizontalHeader().setSectionResizeMode(QHeaderView.Interactive)
self.horizontalHeader().setStretchLastSection(True)
self.verticalHeader().hide()
self._configuration = configuration
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self._header = [
"id", "Name", "Task type", "Abort on miss", "Act. Date (ms)",
"Period (ms)", "List of Act. dates (ms)", "Deadline (ms)",
"WCET (ms)", "ACET (ms)", "ET Std Dev (ms)", "Base CPI",
"Instructions", "MIX", "Stack file", "Preemption cost",
"Followed by", "pET"
]
self._dict_header = {
'id': 0,
'name': 1,
'task_type': 2,
'abort': 3,
'activation_date': 4,
'period': 5,
'list_activation_dates': 6,
'deadline': 7,
'wcet': 8,
'acet': 9,
'et_stddev': 10,
'base_cpi': 11,
'n_instr': 12,
'mix': 13,
'sdp': 14,
'preemption_cost': 15,
'followed': 16,
'p_et': 17
}
self.refresh_table()
self.resizeColumnsToContents()
self.cellChanged.connect(self._cell_changed)
self.cellActivated.connect(self._cell_activated)
def __init__(self, parent, configuration):
self._ignore_cell_changed = False
self._manual_change = True
self._configuration = configuration
self._caches_list = configuration.caches_list
QTableWidget.__init__(self, len(self._caches_list), 5, parent)
self.horizontalHeader().setStretchLastSection(True)
self.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.setHorizontalHeaderLabels(["id", "Name", "Size", 'Access Time',
"Miss penalty"])
self.setVerticalHeaderLabels([""])
self.verticalHeader().hide()
self.setSelectionBehavior(QAbstractItemView.SelectRows)
curRow = 0
for cache in self._caches_list:
self._add_cache_to_table(curRow, cache)
curRow += 1
self.cellChanged.connect(self._cell_changed)
def __init__(self, parent, configuration):
self._ignore_cell_changed = False
self._manual_change = True
self._configuration = configuration
self._caches_list = configuration.caches_list
QTableWidget.__init__(self, len(self._caches_list), 5, parent)
self.horizontalHeader().setStretchLastSection(True)
self.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.setHorizontalHeaderLabels(
["id", "Name", "Size", 'Access Time', "Miss penalty"])
self.setVerticalHeaderLabels([""])
self.verticalHeader().hide()
self.setSelectionBehavior(QAbstractItemView.SelectRows)
curRow = 0
for cache in self._caches_list:
self._add_cache_to_table(curRow, cache)
curRow += 1
self.cellChanged.connect(self._cell_changed)
def __init__(self, data, headers, *args, selectable=False):
QTableWidget.__init__(self, *args)
self.data = data
self.setHorizontalHeaderLabels(headers)
for n, row in enumerate(self.data):
for m, value in enumerate(row):
item = QTableWidgetItem(value)
if selectable is not False and m == selectable:
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
else:
item.setFlags(Qt.ItemIsEnabled)
item.setToolTip(value)
self.setItem(n, m, item)
self.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.clicked.connect(self.on_click)
def __init__(self, data, *args):
QTableWidget.__init__(self, *args)
self.data = data
self.setmydata()
self.resizeColumnsToContents()
self.resizeRowsToContents()
font = QtGui.QFont()
font.setFamily("Product Sans")
font.setPointSize(10)
font.setWeight(55)
self.setFont(font)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(sizePolicy)
def __init__(self, wheres_the_fck_receipt: api_interface.WheresTheFckReceipt, parent=None):
QTableWidget.__init__(self, parent)
self.wheres_the_fck_receipt = wheres_the_fck_receipt
# settings table
self.setShowGrid(True)
# self.setSelectionMode(QAbstractItemView.SingleSelection)
# self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.setColumnCount(3)
self.setHorizontalHeaderLabels(['Key', 'Value', 'Help'])
header = self.horizontalHeader()
header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
header.setStretchLastSection(True)
row = 0
settings = wheres_the_fck_receipt.get_settings()
for key, value_help_type in settings.items():
key_item = QTableWidgetItem(key)
key_item.setFlags(key_item.flags() ^ Qt.ItemIsEditable)
value_ = value_help_type[0]
type_ = value_help_type[2]
value_item = QTableWidgetItem(value_)
value_item.setData(Qt.UserRole, type_)
# value_item.setFlags(value_item.flags() & Qt.ItemIsEditable)
help_ = value_help_type[1]
# help_item = QTableWidgetItem(help_)
# help_item.setFlags(help_item.flags() ^ Qt.ItemIsEditable)
help_item = QLabel(help_)
help_item.setTextFormat(Qt.RichText)
help_item.setOpenExternalLinks(True)
self.insertRow(row)
self.setItem(row, 0, key_item)
self.setItem(row, 1, value_item)
# self.setItem(row, 2, help_item)
self.setCellWidget(row, 2, help_item)
row = row + 1
self.cellChanged.connect(self.on_cell_changed)
def __init__(self, parent, configuration):
QTableWidget.__init__(self, 0, 0, parent)
self._ignore_cell_changed = False
self.horizontalHeader().setSectionResizeMode(QHeaderView.Interactive)
self.horizontalHeader().setStretchLastSection(True)
self.verticalHeader().hide()
self._configuration = configuration
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self._header = ["id", "Name", "Task type", "Abort on miss",
"Act. Date (ms)", "Period (ms)",
"List of Act. dates (ms)", "Deadline (ms)",
"WCET (ms)", "ACET (ms)", "ET Std Dev (ms)",
"Base CPI", "Instructions", "MIX",
"Stack file", "Preemption cost", "Followed by"]
self._dict_header = {
'id': 0,
'name': 1,
'task_type': 2,
'abort': 3,
'activation_date': 4,
'period': 5,
'list_activation_dates': 6,
'deadline': 7,
'wcet': 8,
'acet': 9,
'et_stddev': 10,
'base_cpi': 11,
'n_instr': 12,
'mix': 13,
'sdp': 14,
'preemption_cost': 15,
'followed': 16
}
self.refresh_table()
self.resizeColumnsToContents()
self.cellChanged.connect(self._cell_changed)
self.cellActivated.connect(self._cell_activated)
def __init__(self, tableData, *args):
QTableWidget.__init__(self, *args)
#Table widget specifications.
self.tableData = tableData
self.setData()
self.resizeColumnsToContents()
self.resizeRowsToContents()
self.setWindowTitle("Premier league table")
#Window specifications.
self.top = 100
self.left = 100
self.width = 880
self.height = 490
self.setGeometry(self.top, self.left, self.width, self.height)
#Instructions specifications.
instructionLabel = QLabel(self)
instructionLabel.move(450, 40)
instructionLabel.setText(''' Instructions:
Select an available date from the calendar to display a table
of Premier League results determined only from the selected date
until present.''')
#Date picker specifications.
cal = QCalendarWidget(self)
cal.setGridVisible(True)
cal.move(500, 140)
#Limiting date picker to dates from the beginning of the current season to now.
max_date = QDate.fromString(
datetime.datetime.now().strftime("%Y-%m-%d"), 'yyyy-MM-dd')
min_date = QDate.fromString(currentLeagueStartDate, 'yyyy-MM-dd')
cal.setMaximumDate(max_date)
cal.setMinimumDate(min_date)
#Changing data displayed in table to reflect information only from the selected date.
cal.clicked[QDate].connect(
lambda: self.changeData(cal.selectedDate().toString("yyyy-MM-dd")))
def __init__(self, parent=None):
QTableWidget.__init__(self, parent)
self.myBrush = QBrush()
self.myPen = QPen()
self.pathPen = QPen()
self.pathPenMiddle = QPen()
self.lastPoints = [QPoint(), QPoint()]
self.parent = parent
self.target = None
self.pixmap = None
self.pixmapHandwriting = None
self.deviceDown = False
self.timer = QTimer()
self.drawLineTimer = QTimer()
self.pressure = 0.0
self.penX = -1000.0
self.penY = -1000.0
self.yTilt = 0.0
self.xTilt = 0.0
self.targetPixmap = None
self.naoPixmap = None
self.path = []
self.pathIndex = 0
self.robotReady = False
self.traceIndexMax = 0
self.naoPosition = 0.0
self.naoSpeed = 1.0
self.activeNaoHead = False
self.naoSpeedFactor = DEFAULT_NAO_SPEED_FACTOR
self.data = []
self.time = QTime()
self.penTraceWidth = DEFAULT_PEN_TRACE_WIDTH
self.initPixmaps()
self.setAutoFillBackground(True)
self.setCursor(Qt.BlankCursor)
self.timer.timeout.connect(self.frameUpdate)
self.drawLineTimer.timeout.connect(self.drawNextLineSeg)
self.timer.start(FRAME_TIME)
self.time.start()
def __init__(self, parent, configuration):
QTableWidget.__init__(self, 5, 1, parent)
self._configuration = configuration
self._manual_change = True
self.setVerticalHeaderLabels([
"Duration (cycles)", "Duration (ms)", "Cycles / ms",
'RAM access time', 'Execution Time Model'
])
self.horizontalHeader().setStretchLastSection(True)
self.horizontalHeader().hide()
self.setItem(0, 0, QTableWidgetItem(str(configuration.duration)))
self.setItem(
1, 0,
QTableWidgetItem(
str(
float(configuration.duration) /
configuration.cycles_per_ms)))
self.setItem(2, 0, QTableWidgetItem(str(configuration.cycles_per_ms)))
self.setItem(3, 0,
QTableWidgetItem(str(configuration.memory_access_time)))
item = QComboBox(self)
selected = 0
for i, (etm_name, etm_code) in \
enumerate(execution_time_model_names.items()):
item.addItem(etm_name)
if etm_code == configuration.etm:
selected = i
item.setCurrentIndex(selected)
self.setCellWidget(4, 0, item)
def activation_handler(x):
configuration.etm = execution_time_model_names[str(x)]
configuration.conf_changed()
item.activated['QString'].connect(activation_handler)
# self._update_observe_window()
self.cellChanged.connect(self._cell_changed)
def __init__(self,
parent=None,
featureGroups=[],
sigmas=[],
computeIn2d=[],
window_size=3.5):
"""
Args:
featureGroups: A list with schema: [ (groupName1, [entry, entry...]),
(groupName2, [entry, entry...]), ... ]
sigmas: List of sigmas (applies to all features)
computeIn2d: List of booleans to indicate which sigma column should be computed in 2d (rather than 3d)
"""
QTableWidget.__init__(self, parent)
self.setCornerButtonEnabled(False)
self.setEditTriggers(QAbstractItemView.AllEditTriggers)
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.setShowGrid(False)
self.setMouseTracking(1)
self.verticalHeader().setHighlightSections(False)
self.verticalHeader().setSectionsClickable(True)
self.verticalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.verticalHeader().sectionPressed.disconnect()
self.verticalHeader().sectionClicked.connect(
self._expandOrCollapseVHeader)
self.horizontalHeader().setHighlightSections(False)
self.horizontalHeader().setSectionsClickable(False)
# self.horizontalHeader().installEventFilter(self)
self.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.itemSelectionChanged.connect(self._itemSelectionChanged)
self.cellChanged.connect(self._cellChanged)
if featureGroups or sigmas or computeIn2d:
self.setup(featureGroups, sigmas, computeIn2d, window_size)
def __init__(self, toolbar=None):
QTableWidget.__init__(self)
self.toolbar = toolbar
self.paste_callback = None
self.setSelectionBehavior(QAbstractItemView.SelectItems)
self.SelectionMode(QAbstractItemView.SingleSelection)
if self.toolbar != None:
self.toolbar.setIconSize(QSize(32, 32))
self.tb_add = QAction(icon_get("list-add"), _("Add"), self)
self.toolbar.addAction(self.tb_add)
self.tb_remove = QAction(icon_get("list-remove"), _("Delete row"),
self)
self.toolbar.addAction(self.tb_remove)
self.tb_remove.triggered.connect(self.emit_remove_rows)
self.tb_down = QAction(icon_get("go-down"), _("Move down"), self)
self.toolbar.addAction(self.tb_down)
self.tb_up = QAction(icon_get("go-up"), _("Move up"), self)
self.toolbar.addAction(self.tb_up)
self.menu = QMenu(self)
self.menu_copy = QAction(_("Copy"), self)
self.menu_copy.triggered.connect(self.callback_menu_copy)
self.menu.addAction(self.menu_copy)
self.menu_paste = QAction(_("Paste"), self)
self.menu.addAction(self.menu_paste)
self.menu_paste.triggered.connect(self.callback_menu_paste)
self.menu_delete = QAction(icon_get("list-remove"), _("Delete row"),
self)
self.menu.addAction(self.menu_delete)
self.menu_delete.triggered.connect(self.emit_remove_rows)
def __init__(self, sequence, ttls=None, dacs=None, dds=None, adcs=None, time_unit='s'):
QTableWidget.__init__(self)
self.time_unit = time_unit
self.children = []
self.set_sequence(sequence)
self.horizontal_margin = 5
self.label_width = 35
self.setHorizontalHeader(CustomHeader(self))
self.hold_column = None
self.menu = None
self.tabs = QTabWidget()
if ttls is not None:
self.ttl_table = TTLTable(self, ttls)
self.tabs.addTab(self.ttl_table, 'TTL')
if adcs is not None:
self.adc_table = ADCTable(self, adcs)
self.tabs.addTab(self.adc_table, 'ADC')
if dacs is not None:
self.dac_table = DACTable(self, dacs)
self.tabs.addTab(self.dac_table, 'DAC')
if dds is not None:
self.dds_table = DDSTable(self, dds)
self.tabs.addTab(self.dds_table, 'DDS')
def __init__(self):
QTableWidget.__init__(self)
# initialise table
self.no_of_cols = 5
self.setColumnCount(self.no_of_cols)
tableHeader = self.horizontalHeader()
self.setHorizontalHeaderItem(0, QTableWidgetItem('Name'))
self.setHorizontalHeaderItem(1, QTableWidgetItem('Amount'))
self.setHorizontalHeaderItem(2, QTableWidgetItem('Category'))
self.setHorizontalHeaderItem(3, QTableWidgetItem(' '))
self.setHorizontalHeaderItem(4, QTableWidgetItem(' '))
tableHeader.setSectionResizeMode(0, QHeaderView.Stretch)
tableHeader.setSectionResizeMode(1, QHeaderView.Stretch)
tableHeader.setSectionResizeMode(2, QHeaderView.Stretch)
# set edit and delete button to be as small as their text
tableHeader.setSectionResizeMode(3, QHeaderView.ResizeToContents)
tableHeader.setSectionResizeMode(4, QHeaderView.ResizeToContents)
headerFont = QFont('SansSerif', 12)
tableHeader.setFont(headerFont)
def __init__(self):
QTableWidget.__init__(self)
self.setWindowTitle("QTableWidget Cell Click")
self.setRowCount(1)
self.setColumnCount(2)
def __init__(self, *args):
QTableWidget.__init__(self, *args)
self.setmydata()
self.itemSelectionChanged.connect(self.slot)
self.setItemDelegate(delegate(self))
def __init__(self, parent=None):
QTableWidget.__init__(self, parent)
self.axistags = None
def __init__(self, game, parent):
QTableWidget.__init__(
self, settings.ROWS, settings.COLUMNS, parent)
self.parent = parent
self.game = game
self.refresh_data(game, parent)
