コード例 #1
0
 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)
コード例 #2
0
ファイル: featureTableWidget.py プロジェクト: ilastik/ilastik
    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)
コード例 #3
0
ファイル: GeneralTab.py プロジェクト: MaximeCheramy/simso-gui
    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)
コード例 #4
0
ファイル: Logs.py プロジェクト: MaximeCheramy/simso-gui
 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()
コード例 #5
0
ファイル: LoadTab.py プロジェクト: MaximeCheramy/simso-gui
    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()
コード例 #6
0
ファイル: Grillas.py プロジェクト: oscarvogel/pyqt5libs
    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'])
コード例 #7
0
    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
コード例 #8
0
ファイル: 02.py プロジェクト: JHadley1406/udemy_coursework
 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)
コード例 #9
0
    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)
コード例 #10
0
ファイル: TasksTab.py プロジェクト: wzh201434/simso-gui
    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()
コード例 #11
0
 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()
コード例 #12
0
ファイル: ProcessorsTab.py プロジェクト: wzh201434/simso-gui
 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()
コード例 #13
0
    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)
コード例 #14
0
ファイル: Table.py プロジェクト: zazachubin/Money-tracker
 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)
コード例 #15
0
    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 = []
コード例 #16
0
    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)
コード例 #17
0
    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
コード例 #18
0
    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)
コード例 #19
0
    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)
コード例 #20
0
    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()
コード例 #21
0
 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)
コード例 #22
0
 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
コード例 #23
0
    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()
コード例 #24
0
    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)
コード例 #25
0
ファイル: CachesTab.py プロジェクト: MaximeCheramy/simso-gui
    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)
コード例 #26
0
ファイル: CachesTab.py プロジェクト: wzh201434/simso-gui
    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)
コード例 #27
0
ファイル: table.py プロジェクト: VladBarbak/Course-Work
    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)
コード例 #28
0
    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)
コード例 #29
0
    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)
コード例 #30
0
ファイル: TasksTab.py プロジェクト: MaximeCheramy/simso-gui
    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)
コード例 #31
0
    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")))
コード例 #32
0
    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()
コード例 #33
0
ファイル: GeneralTab.py プロジェクト: wzh201434/simso-gui
    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)
コード例 #34
0
    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)
コード例 #35
0
    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)
コード例 #36
0
    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')
コード例 #37
0
    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)
コード例 #38
0
ファイル: QTableWidget1.py プロジェクト: skyballoon/PyQtTest
 def __init__(self):
   QTableWidget.__init__(self)
   self.setWindowTitle("QTableWidget Cell Click")
   self.setRowCount(1)
   self.setColumnCount(2)
コード例 #39
0
ファイル: tableData.py プロジェクト: esmam/MRATPython27
 def __init__(self,  *args):
     QTableWidget.__init__(self, *args)
     self.setmydata()
     self.itemSelectionChanged.connect(self.slot)
     self.setItemDelegate(delegate(self))
コード例 #40
0
 def __init__(self, parent=None):
     QTableWidget.__init__(self, parent)
     self.axistags = None
コード例 #41
0
 def __init__(self, game, parent):
     QTableWidget.__init__(
         self, settings.ROWS, settings.COLUMNS, parent)
     self.parent = parent
     self.game = game
     self.refresh_data(game, parent)