Beispiel #1
0
class ValueEdit(QWidget):
    def __init__(self, title, unit, number_type='double', parent=None):
        super(ValueEdit, self).__init__(parent)
        self.title = QLabel(title)
        self.title.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
        self.unit = QLabel(unit)
        self.unit.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)

        if number_type == 'double':
            self.edit = QDoubleSpinBox()
        elif number_type == 'int':
            self.edit = QSpinBox()
        else:
            raise ValueError(
                'Editor can either be for double or integer values')

        self.edit.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
        self.edit.setKeyboardTracking(False)
        self.edit.setAlignment(Qt.AlignRight)
        self.edit.setButtonSymbols(QAbstractSpinBox.NoButtons)

    def set_range_decimals(self, min, max, decimals=3):
        self.edit.setRange(min, max)
        if isinstance(self.edit, QDoubleSpinBox):
            self.edit.setDecimals(decimals)

    def set_single_step_size(self, step=.1):
        self.edit.setSingleStep(step)

    def value(self):
        return self.edit.value()

    @Slot(float)
    def setValue(self, value):
        self.edit.setValue(value)
Beispiel #2
0
class StatInitDialog(QDialog):

    def __init__(self, stats):
        QDialog.__init__(self)
        self.stats = stats
        self.setWindowTitle("Initialization")
        self.setMinimumWidth(200)
        self.layout = QFormLayout()
        self.kill_spinbox = QSpinBox()
        self.death_spinbox = QSpinBox()
        self.kill_spinbox.setRange(0,1000000)
        self.death_spinbox.setRange(0,1000000)
        self.layout.addRow(QLabel("Kills"), self.kill_spinbox)
        self.layout.addRow(QLabel("Deaths"), self.death_spinbox)
        self.buttonBox = QDialogButtonBox(QDialogButtonBox.Cancel | QDialogButtonBox.Ok)
        self.layout.addWidget(self.buttonBox)
        self.setLayout(self.layout)
        self.buttonBox.accepted.connect(self.ok)
        self.buttonBox.rejected.connect(self.cancel)

    def ok(self):
        kills = self.kill_spinbox.value()
        deaths = self.death_spinbox.value()
        self.stats.set_initial_stats(kills, deaths)
        self.accept()

    def cancel(self):
        print("Cancelling the stat initialization")
        self.reject()
Beispiel #3
0
    def add_row(self, grid, choice, name):
        grid.addWidget(QLabel(str(name)), 0)

        spin_box = QSpinBox()
        spin_box.setRange(0, 10)
        cb = partial(self.spin_box_changed, choice, name)
        spin_box.valueChanged.connect(cb)
        if choice not in self.spin_boxes.keys():
            self.spin_boxes[choice] = {name: spin_box}
        else:
            self.spin_boxes[choice].update({name: spin_box})

        slider = QSlider(Qt.Orientation.Horizontal)
        slider.setTickPosition(QSlider.TicksBelow)
        slider.setMaximum(10)
        slider.setPageStep(1)
        slider.setTracking(True)
        cb = partial(self.slider_changed, choice, name)
        slider.valueChanged.connect(cb)
        if choice not in self.sliders.keys():
            self.sliders[choice] = {name: slider}
        else:
            self.sliders[choice].update({name: slider})

        grid.addWidget(spin_box, 1)
        grid.addWidget(slider, 2)
Beispiel #4
0
    def _layout(self):
        layout = QFormLayout(self)
        self.setLayout(layout)

        tooltip_label = QLabel("Display tooltips as", self)
        tooltip_field = QComboBox(self)
        tooltip_field.insertItem(0, "Disabled")
        tooltip_field.insertItem(1, "Notification")  # XXX: Check support
        tooltip_field.insertItem(2, "Cursor tooltip")
        tooltip_field.currentIndexChanged.connect(self.preview_tooltip)
        layout.addRow(tooltip_label, tooltip_field)

        border_field = QCheckBox("Styled window border", self)
        border_field.setDisabled(sys.platform == "darwin")
        border_field.setChecked(sys.platform != "darwin")
        layout.addRow(None, border_field)

        # I think this doesn't belong to "Interface"
        # either rename it to settings or make separate game tab
        capturei_label = QLabel("Capture interval", self)
        capturei_layout = QHBoxLayout()
        capturei_field = QSpinBox(self)
        capturei_field.setRange(100, 2000)
        capturei_field.setSingleStep(100)
        capturei_field.setValue(100)
        capturei_layout.addWidget(capturei_field, 1)
        capturei_unit = QLabel("ms", self)
        capturei_layout.addWidget(capturei_unit, 0)
        layout.addRow(capturei_label, capturei_layout)
Beispiel #5
0
class ToolsWidget(QWidget):

    def __init__(self, parent=None):
        super(ToolsWidget, self).__init__(parent)
        self.initUI()
        pass

    def initUI(self):
        self.contour_epsilon=QSpinBox()
        self.generate_contour=QPushButton();
        self.generate_contour.setText("generate")
        self.contour_epsilon.setRange(3,20)
        self.contour_epsilon.setValue(10)
        l1=QHBoxLayout()
        l2=QVBoxLayout()
        self.b2=QPushButton("插点");
        self.b3=QPushButton();
        self.b4=QPushButton();
        l1.addWidget(self.contour_epsilon)
        l1.addSpacing(30)
        l1.addWidget(self.generate_contour)
        l1.setStretchFactor(self.contour_epsilon,1)
        l1.setStretchFactor(self.generate_contour,1)
        l2.addLayout(l1)
        l2.addWidget(self.b2)
        l2.addWidget(self.b3)
        l2.addWidget(self.b4)
        self.setLayout(l2)
        #面板属性设置
        # self.resize(200,800)
        # self.setAutoFillBackground(True)
        # palette = QPalette()
        # palette.setColor(QPalette.Background, QColor(255, 0, 0))
        pass
class LabeledSpinBox(QWidget):
    valueChanged = Signal(int)

    def __init__(self, label_string, minimum=1, maximum=100, starting_value=0):
        super(LabeledSpinBox, self).__init__()
        self.spinbox = QSpinBox()
        self.spinbox.setRange(minimum, maximum)
        self.spinbox.setSuffix('/{}'.format(maximum))
        self.spinbox.setValue(starting_value)
        self.spinbox.valueChanged.connect(self._valueChanged)
        self.label = QLabel()
        self.label.setText(label_string)

        SpinBoxLayout = QHBoxLayout(self)
        SpinBoxLayout.addWidget(self.label)
        SpinBoxLayout.addWidget(self.spinbox)

    def setValue(self, value, quiet=False):
        if quiet:
            self.spinbox.blockSignals(True)
            self.spinbox.setValue(value)
            self.spinbox.blockSignals(False)
        else:
            self.spinbox.setValue(value)

    def value(self):
        return self.spinbox.value()

    def setRange(self, minimum, maximum):
        self.spinbox.setRange(minimum, maximum)
        self.spinbox.setSuffix("/{}".format(maximum))

    def _valueChanged(self, value):
        self.valueChanged.emit(value)
Beispiel #7
0
    def initializePage(self):
        self.parent_wizard.next_button.setDisabled(True)
        self.sliders = []
        self.spin_boxes = []

        # FIXME: backing too much the returning breaks this
        # Seems to remember values, but visually breaks
        for i, name in enumerate(self.collection()):
            self.grid.addWidget(QLabel(str(name)), i, 0)

            spin_box = QSpinBox()
            spin_box.setRange(0, 10)
            cb = partial(self.spin_box_changed, i)
            spin_box.valueChanged.connect(cb)
            self.spin_boxes.append(spin_box)

            slider = QSlider(Qt.Orientation.Horizontal)
            slider.setTickPosition(QSlider.TicksBelow)
            slider.setMaximum(10)
            slider.setPageStep(1)
            slider.setTracking(True)
            cb = partial(self.slider_changed, i)
            slider.valueChanged.connect(cb)
            self.sliders.append(slider)

            self.grid.addWidget(spin_box, i, 1)
            self.grid.addWidget(slider, i, 2)

        self.fix_tab_order()

        for idx, criterion in enumerate(self.collection()):
            value = self.parent_wizard.main_parent.matrix.df.loc['Weight',
                                                                 criterion]
            if str(value) != 'nan':
                self.spin_boxes[idx].setValue(value)
Beispiel #8
0
class ChangeChannel(QDialog):
    change_channel = Signal(int, bool)
    """Allows the user to change the channel."""
    def __init__(self):
        super(ChangeChannel, self).__init__()

        self.setModal(True)

        self.stop_recording = QCheckBox(self)
        self.channel = QSpinBox(self)

        self.channel.setRange(0, 9999)

        self.button_boxes = QDialogButtonBox(QDialogButtonBox.Ok
                                             | QDialogButtonBox.Cancel)

        self.button_boxes.accepted.connect(self.accepted)
        self.button_boxes.rejected.connect(lambda: self.close())

        self.layout = QFormLayout(self)
        self.layout.addRow("Channel:", self.channel)
        self.layout.addRow("Stop recording if in progress:",
                           self.stop_recording)
        self.layout.addRow(self.button_boxes)

        self.setWindowTitle("Change TiVo channel")
        self.resize(320, 100)

    @Slot()
    def accepted(self):
        self.change_channel.emit(self.channel.value(),
                                 self.stop_recording.isChecked())
        self.close()
Beispiel #9
0
    def __init__(self, target_properties: List[str], parent=None):
        super().__init__(parent)
        self.target_properties = target_properties
        self.target = None

        layout = QGridLayout()
        for i in range(0, 8):
            label = QLabel(text=_EDITOR_LABELS[i])
            layout.addWidget(label, 0, i + 1)
        self.editors = []
        for i in range(0, len(target_properties)):
            self.editors.append([])
            label = QLabel(target_properties[i])
            label.setFixedWidth(80)
            layout.addWidget(label, i + 1, 0)
            for j in range(0, 8):
                editor = QSpinBox()
                editor.setRange(-128, 127)
                editor.setMaximumWidth(60)
                layout.addWidget(editor, row=i + 1, column=j + 1)
                self.editors[-1].append(editor)
                editor.valueChanged.connect(lambda v=None, e=editor, r=i, c=j:
                                            self._on_edit(v, e, r, c))
        self.setLayout(layout)
        self.setFixedHeight(200)
Beispiel #10
0
class ElaWidget(ToolWidget):
    def __init__(self, image, parent=None):
        super(ElaWidget, self).__init__(parent)

        params_layout = QHBoxLayout()
        params_layout.addWidget(QLabel(self.tr('Quality:')))
        self.quality_spin = QSpinBox()
        self.quality_spin.setRange(0, 100)
        self.quality_spin.setSuffix(self.tr(' %'))
        self.quality_spin.valueChanged.connect(self.process)
        params_layout.addWidget(self.quality_spin)

        params_layout.addWidget(QLabel(self.tr('Scale:')))
        self.scale_spin = QSpinBox()
        self.scale_spin.setRange(1, 100)
        self.scale_spin.valueChanged.connect(self.process)
        params_layout.addWidget(self.scale_spin)

        self.equalize_check = QCheckBox(self.tr('Equalized'))
        self.equalize_check.stateChanged.connect(self.process)
        params_layout.addWidget(self.equalize_check)

        params_layout.addStretch()
        default_button = QPushButton(self.tr('Default'))
        default_button.clicked.connect(self.default)
        params_layout.addWidget(default_button)

        self.image = image
        self.viewer = ImageViewer(self.image, self.image)
        self.default()
        self.process()

        main_layout = QVBoxLayout()
        main_layout.addLayout(params_layout)
        main_layout.addWidget(self.viewer)
        self.setLayout(main_layout)

    def process(self):
        equalize = self.equalize_check.isChecked()
        self.scale_spin.setEnabled(not equalize)
        start = time()
        quality = self.quality_spin.value()
        scale = self.scale_spin.value()
        compressed = compress_jpeg(self.image, quality)
        if not equalize:
            ela = cv.convertScaleAbs(cv.subtract(compressed, self.image), None,
                                     scale)
        else:
            ela = cv.merge([
                cv.equalizeHist(c)
                for c in cv.split(cv.absdiff(compressed, self.image))
            ])
        self.viewer.update_processed(ela)
        self.info_message.emit(
            self.tr('Error Level Analysis = {}'.format(elapsed_time(start))))

    def default(self):
        self.quality_spin.setValue(75)
        self.scale_spin.setValue(20)
Beispiel #11
0
class ParamSlider(QWidget):
    valueChanged = Signal(int)

    def __init__(self,
                 interval,
                 ticks=10,
                 reset=0,
                 suffix=None,
                 label=None,
                 bold=False,
                 parent=None):
        super(ParamSlider, self).__init__(parent)

        self.slider = QSlider(Qt.Horizontal)
        self.slider.setRange(interval[0], interval[1])
        self.slider.setTickPosition(QSlider.TicksBelow)
        self.slider.setTickInterval((interval[1] - interval[0] + 1) / ticks)
        self.slider.setSingleStep(1)
        self.slider.setPageStep(1)
        self.slider.setValue(reset)
        self.slider.mouseDoubleClickEvent = self.doubleClicked

        self.spin = QSpinBox()
        self.spin.setRange(interval[0], interval[1])
        self.spin.setValue(reset)
        self.spin.setSuffix(suffix)
        self.spin.setFixedWidth(50)

        self.reset = reset
        self.slider.valueChanged.connect(self.spin.setValue)
        self.spin.valueChanged.connect(self.slider.setValue)
        self.slider.valueChanged.connect(self.valueChanged)

        layout = QHBoxLayout()
        if label is not None:
            lab = QLabel(label)
            modify_font(lab, bold=bold)
            layout.addWidget(lab)
        layout.addWidget(self.slider)
        layout.addWidget(self.spin)
        self.setLayout(layout)
        self.setMaximumWidth(200)

    def doubleClicked(self, _):
        self.slider.setValue(self.reset)
        self.spin.setValue(self.reset)

    def value(self):
        return self.slider.value()

    def setValue(self, value):
        self.spin.setValue(value)
        self.slider.setValue(value)
        self.valueChanged.emit(value)

    def sync(self):
        self.spin.setValue(self.slider.value())
        self.slider.setValue(self.spin.value())
        self.valueChanged.emit(self.slider.value())
Beispiel #12
0
class EchoWidget(ToolWidget):
    def __init__(self, image, parent=None):
        super(EchoWidget, self).__init__(parent)

        self.radius_spin = QSpinBox()
        self.radius_spin.setRange(1, 15)
        self.radius_spin.setSuffix(self.tr(' px'))
        self.radius_spin.setValue(2)
        self.radius_spin.setToolTip(self.tr('Laplacian filter radius'))

        self.contrast_spin = QSpinBox()
        self.contrast_spin.setRange(0, 100)
        self.contrast_spin.setSuffix(self.tr(' %'))
        self.contrast_spin.setValue(85)
        self.contrast_spin.setToolTip(self.tr('Output tonality compression'))

        self.gray_check = QCheckBox(self.tr('Grayscale'))
        self.gray_check.setToolTip(self.tr('Desaturated output mode'))

        self.image = image
        self.viewer = ImageViewer(self.image, self.image, None)
        self.process()

        self.radius_spin.valueChanged.connect(self.process)
        self.contrast_spin.valueChanged.connect(self.process)
        self.gray_check.stateChanged.connect(self.process)

        params_layout = QHBoxLayout()
        params_layout.addWidget(QLabel(self.tr('Radius:')))
        params_layout.addWidget(self.radius_spin)
        params_layout.addWidget(QLabel(self.tr('Contrast:')))
        params_layout.addWidget(self.contrast_spin)
        params_layout.addWidget(self.gray_check)
        params_layout.addStretch()

        main_layout = QVBoxLayout()
        main_layout.addLayout(params_layout)
        main_layout.addWidget(self.viewer)
        self.setLayout(main_layout)

    def process(self):
        start = time()
        kernel = 2 * self.radius_spin.value() + 1
        contrast = int(self.contrast_spin.value() / 100 * 255)
        lut = create_lut(0, contrast)
        laplace = []
        for channel in cv.split(self.image):
            deriv = np.fabs(cv.Laplacian(channel, cv.CV_64F, None, kernel))
            deriv = cv.normalize(deriv, None, 0, 255, cv.NORM_MINMAX,
                                 cv.CV_8UC1)
            laplace.append(cv.LUT(deriv, lut))
        result = cv.merge(laplace)
        if self.gray_check.isChecked():
            result = bgr_to_gray3(result)
        self.viewer.update_processed(result)
        self.info_message.emit('Echo Edge Filter = {}'.format(
            elapsed_time(start)))
Beispiel #13
0
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        form = QFormLayout()

        self.track_id = QSpinBox()
        self.track_id.setDisabled(True)
        self.name = QLineEdit()
        self.album = QComboBox()
        self.media_type = QComboBox()
        self.genre = QComboBox()
        self.composer = QLineEdit()

        self.milliseconds = QSpinBox()
        self.milliseconds.setRange(0, 2147483647)  # <1>
        self.milliseconds.setSingleStep(1)

        self.bytes = QSpinBox()
        self.bytes.setRange(0, 2147483647)
        self.bytes.setSingleStep(1)

        self.unit_price = QDoubleSpinBox()
        self.unit_price.setRange(0, 999)
        self.unit_price.setSingleStep(0.01)
        self.unit_price.setPrefix("$")

        form.addRow(QLabel("Track ID"), self.track_id)
        form.addRow(QLabel("Track name"), self.name)
        form.addRow(QLabel("Composer"), self.composer)
        form.addRow(QLabel("Milliseconds"), self.milliseconds)
        form.addRow(QLabel("Bytes"), self.bytes)
        form.addRow(QLabel("Unit Price"), self.unit_price)

        self.model = QSqlTableModel(db=db)

        self.mapper = QDataWidgetMapper()  # <2>
        self.mapper.setModel(self.model)

        self.mapper.addMapping(self.track_id, 0)  # <3>
        self.mapper.addMapping(self.name, 1)
        self.mapper.addMapping(self.composer, 5)
        self.mapper.addMapping(self.milliseconds, 6)
        self.mapper.addMapping(self.bytes, 7)
        self.mapper.addMapping(self.unit_price, 8)

        self.model.setTable("Track")
        self.model.select()  # <4>

        self.mapper.toFirst()  # <5>

        self.setMinimumSize(QSize(400, 400))

        widget = QWidget()
        widget.setLayout(form)
        self.setCentralWidget(widget)
    def _property_spinbox(self, property_name, range_=(0, 99), parent=None):
        def wrapped(value: int):
            if type(value) == str:
                return
            setattr(self.model, property_name, value)

        spin_box = QSpinBox(parent)
        spin_box.setRange(*range_)
        spin_box.setValue(getattr(self.model, property_name))
        spin_box.valueChanged.connect(wrapped)
        return spin_box
Beispiel #15
0
    def add_labels_and_spinboxes_for_advanced_options(self, elements,
                                                      group_box,
                                                      nexus_to_spinner):
        for nexus_string in elements:
            label = QLabel(nexus_string)
            spinner = QSpinBox()
            spinner.setRange(self.minimum_spinbox_value,
                             self.maximum_spinbox_value)

            group_box.layout().addRow(label, spinner)

            nexus_to_spinner[nexus_string] = spinner
Beispiel #16
0
    def __init__(self):
        super().__init__()
        widget = QSpinBox()  # QDoubleSpinBox()

        widget.setRange(-10, 10)

        widget.setPrefix("$")
        widget.setSuffix("c")
        widget.setSingleStep(1)  # 0.1
        widget.valueChanged.connect(self.value_changed)
        widget.valueChanged[str].connect(self.value_changed_str)

        self.setCentralWidget(widget)
Beispiel #17
0
class CoordinateWidget(QWidget, PropertyWidget):
    position_changed = Signal(int, int)

    def __init__(self, target_property_name):
        QWidget.__init__(self)
        PropertyWidget.__init__(self, target_property_name)
        self.layout = QHBoxLayout()
        self.x_spinbox = QSpinBox()
        self.y_spinbox = QSpinBox()
        self.x_spinbox.setRange(-128, 127)
        self.y_spinbox.setRange(-128, 127)
        self.x_spinbox.setFixedWidth(60)
        self.y_spinbox.setFixedWidth(60)
        self.layout.addWidget(self.x_spinbox)
        self.layout.addWidget(self.y_spinbox)
        self.layout.setAlignment(QtGui.Qt.AlignLeft)
        self.setLayout(self.layout)
        self.x_spinbox.valueChanged.connect(lambda v: self._on_edit(v, 0))
        self.y_spinbox.valueChanged.connect(lambda v: self._on_edit(v, 1))
        self.is_disable_write_back = False

    def _on_edit(self, value, index):
        if self.target:
            buffer = self.target[self.target_property_name].value
            if buffer[index] != value:
                if not self.is_disable_write_back:
                    buffer[index] = self._signed_to_unsigned(value)
                self.position_changed.emit(self.x_spinbox.value(),
                                           self.y_spinbox.value())

    def _on_target_changed(self):
        if self.target:
            buffer = self.target[self.target_property_name].value
            self.x_spinbox.setValue(self._unsigned_to_signed(buffer[0]))
            self.y_spinbox.setValue(self._unsigned_to_signed(buffer[1]))
        else:
            self.x_spinbox.setValue(0)
            self.y_spinbox.setValue(0)

    @staticmethod
    def _unsigned_to_signed(value):
        packed = ctypes.c_byte(value)
        return packed.value

    @staticmethod
    def _signed_to_unsigned(value):
        packed = ctypes.c_ubyte(value)
        return packed.value

    def set_disable_write_back(self, is_disabled: bool):
        self.is_disable_write_back = is_disabled
Beispiel #18
0
class Window(QWidget):
    def __init__(self):
        super().__init__()

        self.threadpool = QThreadPool()

        self.totalTickets = QSpinBox()
        self.totalTickets.setRange(0, 500)
        self.serviceTickets = QSpinBox()
        self.serviceTickets.setRange(0, 250)
        self.incidentTickets = QSpinBox()
        self.incidentTickets.setRange(0, 250)
        self.unassignedTickets = QSpinBox()
        self.unassignedTickets.setRange(0, 200)
        self.reasonOne = QLineEdit()
        self.reasonTwo = QLineEdit()
        self.reasonThree = QLineEdit()
        self.additionalNotes = QTextEdit()

        self.generate_btn = QPushButton("Generate PDF")
        self.generate_btn.pressed.connect(self.generate)

        layout = QFormLayout()
        layout.addRow("Number of tickets today", self.totalTickets)
        layout.addRow("Service tickets", self.serviceTickets)
        layout.addRow("Incident tickets", self.incidentTickets)
        layout.addRow("Unassigned tickets", self.unassignedTickets)
        layout.addRow("Reason for most tickets", self.reasonOne)
        layout.addRow("Second reason for most tickets", self.reasonTwo)
        layout.addRow("Third reason for most tickets", self.reasonThree)

        layout.addRow("additionalNotes", self.additionalNotes)
        layout.addRow(self.generate_btn)

        self.setLayout(layout)

    def generate(self):
        self.generate_btn.setDisabled(True)
        data = {
            'totalTickets': str(self.totalTickets.value()),
            'serviceTickets': str(self.serviceTickets.value()),
            'incidentTickets': str(self.incidentTickets.value()),
            'unassignedTickets': str(self.unassignedTickets.value()),
            'reasonOne': self.reasonOne.text(),
            'reasonTwo': self.reasonTwo.text(),
            'reasonThree': self.reasonThree.text(),
            'additionalNotes': self.additionalNotes.toPlainText()
        }
        g = Generator(data)
        g.signals.file_saved_as.connect(self.generated)
        g.signals.error.connect(print)  # Print errors to console.
        self.threadpool.start(g)

    def generated(self, outfile):
        self.generate_btn.setDisabled(False)
        try:
            os.startfile(outfile)
        except Exception:
            # If startfile not available, show dialog.
            QMessageBox.information(self, "Finished", "PDF has been generated")
Beispiel #19
0
    def create_label_and_spinbox_for_advanced_option(self, nexus_string: str,
                                                     group_box: QGroupBox):
        """
        Creates a SpinBox with a label and adds them to GroupBox then returns the SpinBox.
        :param nexus_string: The nexus string label for the SpinBox.
        :param group_box: The GroupBox that the label and SpinBox should be added to.
        :return: The newly created SpinBox.
        """
        label = QLabel(nexus_string)
        spinner = QSpinBox()
        spinner.setRange(self.minimum_spinbox_value,
                         self.maximum_spinbox_value)
        group_box.layout().addRow(label, spinner)

        return spinner
Beispiel #20
0
class IntEditor(QWidget):
    def __init__(self, minval, maxval, stepsize=1, parent=None):
        super(IntEditor, self).__init__(parent)

        # Editfield
        self.edit = QSpinBox(self)
        self.edit.setKeyboardTracking(False)
        self.edit.setRange(minval, maxval)
        self.edit.setSingleStep(stepsize)
        self.edit.setMinimumWidth(70)

        # Slider
        self.slider = QSlider(orientation=Qt.Vertical, parent=self)
        self.slider.setRange(minval, maxval)
        self.slider.setSingleStep(stepsize)
        self.slider.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Expanding)

        # Ticks
        q_ticks = QSlider.TicksBelow
        self.slider.setTickPosition(q_ticks)
        tick_amount = 6
        tick_interval = int(np.floor((maxval - minval) / tick_amount))
        self.slider.setTickInterval(tick_interval)

        # ...labels
        font = QFont()
        font.setPointSize(8)
        tick_str1 = QLabel('{:d}'.format(minval), self)
        tick_str2 = QLabel('{:d}'.format(maxval), self)
        tick_str1.setFont(font)
        tick_str2.setFont(font)
        slider_tick_layout = QGridLayout()
        tick_str1.setAlignment(Qt.AlignBottom | Qt.AlignLeft)
        tick_str2.setAlignment(Qt.AlignTop | Qt.AlignLeft)
        slider_tick_layout.addWidget(self.slider, 0, 0, tick_amount, 1)
        slider_tick_layout.addWidget(tick_str2, 0, 1, 1, 1)
        slider_tick_layout.addWidget(tick_str1, tick_amount - 1, 1, 1, 1)

        # Layout
        layout = QVBoxLayout()
        layout.addLayout(slider_tick_layout)
        layout.addWidget(self.edit)

        self.setLayout(layout)

        # Signals and slots
        self.edit.valueChanged.connect(self.slider.setValue)
        self.slider.valueChanged.connect(self.edit.setValue)
Beispiel #21
0
    def initializePage(self):
        self.parent_wizard.next_button.setDisabled(True)
        # grid
        # |----> groupbox 1 (for choice 1)
        #        |----> vertical_layout 1
        #               |----> inner_grid 1 (for criteria 1)
        #                      |----> label1
        #                      |----> value_spin_box 1
        #               |----> inner_grid 2 (for criteria 2)
        #                      |----> label2
        #                      |----> rating_spin_box 2
        # |----> groupbox 2 (for choice 2)
        #        |-...
        # TODO: consider extracting out common code with
        # AbstractSliderPage
        for choice in self.parent_wizard.main_parent.matrix.df.index[1:]:
            groupbox = QGroupBox(choice)
            vertical_layout = QVBoxLayout(groupbox)
            self.grid.addWidget(groupbox)
            self.spin_boxes[choice] = []
            self.sliders[choice] = []

            for row, criterion in enumerate(
                    self.parent_wizard.main_parent.matrix.criteria):
                rating_spin_box = QSpinBox()
                rating_spin_box.setRange(0, 10)
                self.spin_boxes[choice].append(rating_spin_box)

                slider = QSlider(Qt.Orientation.Horizontal)
                slider.setTickPosition(QSlider.TicksBelow)
                slider.setMaximum(10)
                slider.setPageStep(1)
                slider.setTracking(True)
                self.sliders[choice].append(slider)

                cb = partial(self.spin_box_changed, row, choice, criterion)
                rating_spin_box.valueChanged.connect(cb)

                cb = partial(self.slider_changed, row, choice, criterion)
                slider.valueChanged.connect(cb)

                spin_box_and_slider = QHBoxLayout()
                spin_box_and_slider.addWidget(rating_spin_box)
                spin_box_and_slider.addWidget(slider)

                inner_form = QFormLayout()
                inner_form.addRow(QLabel(criterion), spin_box_and_slider)
                vertical_layout.addLayout(inner_form)
Beispiel #22
0
class SeedWidget(QGroupBox):
    def __init__(self, *args, **kwargs):
        super().__init__("Seed", *args, **kwargs)

        self.seed_spin = QSpinBox()
        self.seed_spin.setRange(0, _MAX_SEED)
        randomize_btn = QPushButton("Randomize")
        randomize_btn.clicked.connect(self.randomize_seed)

        layout = QFormLayout()
        layout.addRow("Seed:", self.seed_spin)
        layout.addRow("", randomize_btn)
        self.setLayout(layout)

    def randomize_seed(self):
        self.seed_spin.setValue(random.randint(0, _MAX_SEED))
Beispiel #23
0
    def make_ui(self):
        """Create and lay out UI elements."""

        filter = QSpinBox()
        filter.setRange(1, 6)
        self.widgets['filter'] = filter

        btn_start = QPushButton()
        btn_start.setText('Start')
        btn_start.clicked.connect(self.run)
        self.widgets['btn_start'] = btn_start

        side_panel = QGridLayout()
        side_panel.setColumnStretch(0, 0)
        side_panel.setColumnStretch(1, 1)
        side_panel.setColumnStretch(2, 1)
        side_panel.setRowStretch(6, 1)  # shove everything to the top

        side_panel.addWidget(QLabel('<h2>Controls</h2>'), 0, 0, 1, 2)
        side_panel.addWidget(QLabel('Filter:'), 1, 0)
        side_panel.addWidget(filter, 1, 1)
        side_panel.addWidget(btn_start, 2, 0, 1, 2)

        graph = FigureCanvas(Figure(tight_layout=True))
        graph_toolbar = NavigationToolBar(graph, None)
        graph_toolbar.setObjectName('GraphToolBar')
        self.widgets['graph'] = graph
        axis = graph.figure.subplots()
        axis.grid()
        axis.set_xlim(0, 100)
        axis.set_ylim(0, 10)

        self.widgets['axis'] = axis

        vbox = QVBoxLayout()
        vbox.addWidget(graph)
        vbox.addWidget(graph_toolbar)

        hbox = QHBoxLayout()
        hbox.addLayout(side_panel)
        hbox.addLayout(vbox, 1)

        main_widget = QFrame()
        main_widget.setLayout(hbox)

        return main_widget
def init_letter_spacing_widget(text_item):
    letter_spacing_layout = QVBoxLayout()
    letter_spacing_type_combo_box = QComboBox()
    letter_spacing_value_input = QSpinBox()
    letter_spacing_value_input.setRange(-10000, 10000)

    letter_spacing_types = {QFont.PercentageSpacing: "Percentage spacing",
                            QFont.AbsoluteSpacing: "Absolute spacing"}
    for letter_spacing_type in letter_spacing_types.values():
        letter_spacing_type_combo_box.addItem(letter_spacing_type)
    current_spacing_type = text_item.font().letterSpacingType()
    letter_spacing_type_combo_box.setCurrentText(
        letter_spacing_types[current_spacing_type])
    letter_spacing_type_combo_box.currentTextChanged.connect(lambda x:
                                                             set_letter_spacing_type(
                                                                 text_item,
                                                                 x,
                                                                 letter_spacing_value_input,
                                                                 units_label))

    letter_spacing_layout.addWidget(letter_spacing_type_combo_box)

    current_spacing = int(text_item.font().letterSpacing())
    if current_spacing_type == QFont.PercentageSpacing and \
            current_spacing == 0:
        letter_spacing_value_input.setValue(100)
    else:
        letter_spacing_value_input.setValue(current_spacing)
    letter_spacing_value_input.valueChanged.connect(lambda:
                                                     set_letter_spacing_value(
                                                         text_item,
                                                         letter_spacing_type_combo_box,
                                                         letter_spacing_value_input))
    letter_spacing_value_input_layout = QHBoxLayout()
    letter_spacing_value_input_layout.addWidget(letter_spacing_value_input)
    units_label = QLabel()
    if current_spacing_type == QFont.PercentageSpacing:
        units_label.setText("%")
    else:
        units_label.setText("px")
    letter_spacing_value_input_layout.addWidget(units_label)
    letter_spacing_layout.addLayout(letter_spacing_value_input_layout)
    letter_spacing_group_box = QGroupBox("Letter spacing")
    letter_spacing_group_box.setLayout(letter_spacing_layout)
    return letter_spacing_group_box
Beispiel #25
0
class MillerArrayTableForm(QDialog):
    def __init__(self, parent=None):
        super(MillerArrayTableForm, self).__init__(parent.window)
        self.setWindowFlag(Qt.WindowContextHelpButtonHint, False)
        self.setWindowTitle("Tabulated Reflection Data")
        self.precision_spinBox = QSpinBox()
        self.precision_spinBox.setSingleStep(1)
        self.precision_spinBox.setRange(1, 20)
        self.precision_spinBox.setValue(3)
        self.precision_spinBox.valueChanged.connect(parent.onPrecisionChanged)
        precision_labeltxt = QLabel()
        precision_labeltxt.setText("Precision:")
        self.SortComboBox = QComboBox()
        self.SortComboBox.activated.connect(parent.onSortComboBoxSelchange)
        sort_labeltxt = QLabel()
        sort_labeltxt.setText("Sort according to:")
        self.sortChkbox = QCheckBox()
        self.sortChkbox.setCheckState(Qt.Unchecked)
        self.sortChkbox.setText("Ascending order")
        self.sortChkbox.clicked.connect(parent.onSortChkbox)
        self.myGroupBox = QGroupBox()
        self.layout = QGridLayout()
        self.layout.addWidget(precision_labeltxt, 0, 0, 1, 1)
        self.layout.addWidget(self.precision_spinBox, 0, 1, 1, 1)
        self.layout.addWidget(sort_labeltxt, 0, 2, 1, 1)
        self.layout.addWidget(self.SortComboBox, 0, 3, 1, 1)
        self.layout.addWidget(self.sortChkbox, 0, 4, 1, 1)
        self.layout.addWidget(parent.millerarraytable, 1, 0, 1, 5)
        self.layout.setColumnStretch(0, 0)
        self.layout.setColumnStretch(1, 0)
        self.layout.setColumnStretch(2, 0)
        self.layout.setColumnStretch(3, 0)
        self.layout.setColumnStretch(4, 1)
        self.myGroupBox.setLayout(self.layout)
        self.mainLayout = QGridLayout()
        self.mainLayout.addWidget(self.myGroupBox, 0, 0)
        self.setLayout(self.mainLayout)

    def eventFilter(self, source, event):
        if (event.type() == QEvent.KeyPress
                and event.matches(QKeySequence.Copy)):
            self.parent().parent.millerarraytable.copySelection()
            return True
        return super(MillerArrayTableForm, self).eventFilter(source, event)
Beispiel #26
0
class DaemonIntervalControls(QWidget):
    def __init__(self, tool):
        QWidget.__init__(self)

        self.tool = tool

        self.layout = QBoxLayout(QBoxLayout.LeftToRight)

        self.layout.addWidget(QLabel("Update interval: "))

        self.period_select = QSpinBox()
        self.period_select.setRange(100, 1000 * 60 * 240)  # 240 seconds max
        self.period_select.setSingleStep(100)
        self.layout.addWidget(self.period_select)

        self.layout.addWidget(QLabel("ms"))

        self.layout.setStretch(1, 1)

        self.setLayout(self.layout)
Beispiel #27
0
    def create_rating_ticker(self, i, rating):
        """Creates the rating ticker that is displayed on the Local Storage
        View tab's QTableView. Each QSpinBox is mapped to a row, representing
        the rating of the patch.

        i: The current row the buttons are being created for.
        rating: The current rating associated with the selected patch.
        """

        if rating < 0 or rating > 5:
            raise errors.SortingError(rating, 901)

        rate_tkr = QSpinBox()
        rate_tkr.setValue(rating)
        rate_tkr.setRange(0, 5)
        rate_tkr.setSingleStep(1)
        rate_tkr.valueChanged.connect(self.update_rating)

        rate_tkr.setFont(self.ui.table_PS.horizontalHeader().font())
        self.ui.table_local.setCellWidget(i, 4, rate_tkr)
class EditSlider(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)

        hlayout = QHBoxLayout()
        hlayout.setContentsMargins(0, 0, 0, 0)
        hlayout.setSpacing(2)

        self.edit = QSpinBox()
        self.edit.setMinimumWidth(40)
        self.edit.setButtonSymbols(QAbstractSpinBox.NoButtons)
        self.slider = QSlider(Qt.Horizontal)

        hlayout.addWidget(self.edit)
        hlayout.addWidget(self.slider)

        self.setLayout(hlayout)

        self.slider.valueChanged.connect(self.setValue)
        self.edit.valueChanged.connect(self.setValue)

    def setRange(self, min_val, max_val):
        self.edit.setRange(min_val, max_val)
        self.slider.setRange(min_val, max_val)

    def value(self) -> int:
        return self.edit.value()

    def setValue(self, value: int):

        if self.sender() != self.slider and self.sender() != self.edit:
            self.edit.setValue(value)
            self.slider.setValue(value)
            return

        if self.sender() == self.slider:
            self.edit.setValue(value)

        if self.sender() == self.edit:
            self.slider.setValue(value)
Beispiel #29
0
    def add_row(self, criterion, deleteable=True):
        # The last row for this criterion
        index = self.rows_for_each_criteria[criterion]

        value_spin_box = QSpinBox()
        value_spin_box.setRange(0, 100)
        self.value_spin_boxes[criterion].append(value_spin_box)

        score_spin_box = QSpinBox()
        score_spin_box.setRange(0, 100)
        self.score_spin_boxes[criterion].append(score_spin_box)

        delete_button = QPushButton('&Delete')
        cb = partial(self.delete, criterion, index)
        delete_button.clicked.connect(cb)
        size_policy = QSizePolicy()
        size_policy.setRetainSizeWhenHidden(True)
        delete_button.setSizePolicy(size_policy)

        cb = partial(self.value_changed, criterion, index)
        value_spin_box.valueChanged.connect(cb)
        cb = partial(self.score_changed, criterion, index)
        score_spin_box.valueChanged.connect(cb)

        inner_grid = QGridLayout()
        inner_grid.addWidget(value_spin_box, index, 0)
        inner_grid.addWidget(QLabel('then score should be '), index, 1)
        inner_grid.addWidget(score_spin_box, index, 2)
        inner_grid.addWidget(delete_button, index, 3)
        if not deleteable:
            delete_button.hide()

        form = QFormLayout()
        form.addRow(QLabel('If ' + str(criterion) + ' is '), inner_grid)

        pos = self.vertical_layouts[criterion].count() - 1
        self.vertical_layouts[criterion].insertLayout(pos, form)

        # Increment the row number
        self.rows_for_each_criteria[criterion] += 1
Beispiel #30
0
class IntegerFilterWidget(AbstractFilterWidget):
    def __init__(self, field: str, parent=None):
        super().__init__(parent)

        self.field = field
        vlayout = QVBoxLayout()
        vlayout.setContentsMargins(0, 0, 0, 0)
        self.edit = QSpinBox()
        vlayout.addWidget(self.edit)
        self.setLayout(vlayout)

        self.edit.valueChanged.connect(self.changed)

    def setup(self, conn: sqlite3.Connection):
        field_min, field_max = sql.get_field_range(conn, self.field)

        self.edit.setRange(field_min, field_max)

    def get_filters(self):
        name = self.field
        value = self.edit.value()
        return f"({name} == {value})"
Beispiel #31
0
class Window(QWidget):
    def __init__(self):
        super(Window, self).__init__()

        self.renderArea = RenderArea()

        self.shapeComboBox = QComboBox()
        self.shapeComboBox.addItem("Polygon", RenderArea.Polygon)
        self.shapeComboBox.addItem("Rectangle", RenderArea.Rect)
        self.shapeComboBox.addItem("Rounded Rectangle", RenderArea.RoundedRect)
        self.shapeComboBox.addItem("Ellipse", RenderArea.Ellipse)
        self.shapeComboBox.addItem("Pie", RenderArea.Pie)
        self.shapeComboBox.addItem("Chord", RenderArea.Chord)
        self.shapeComboBox.addItem("Path", RenderArea.Path)
        self.shapeComboBox.addItem("Line", RenderArea.Line)
        self.shapeComboBox.addItem("Polyline", RenderArea.Polyline)
        self.shapeComboBox.addItem("Arc", RenderArea.Arc)
        self.shapeComboBox.addItem("Points", RenderArea.Points)
        self.shapeComboBox.addItem("Text", RenderArea.Text)
        self.shapeComboBox.addItem("Pixmap", RenderArea.Pixmap)

        shapeLabel = QLabel("&Shape:")
        shapeLabel.setBuddy(self.shapeComboBox)

        self.penWidthSpinBox = QSpinBox()
        self.penWidthSpinBox.setRange(0, 20)
        self.penWidthSpinBox.setSpecialValueText("0 (cosmetic pen)")

        penWidthLabel = QLabel("Pen &Width:")
        penWidthLabel.setBuddy(self.penWidthSpinBox)

        self.penStyleComboBox = QComboBox()
        self.penStyleComboBox.addItem("Solid", Qt.SolidLine)
        self.penStyleComboBox.addItem("Dash", Qt.DashLine)
        self.penStyleComboBox.addItem("Dot", Qt.DotLine)
        self.penStyleComboBox.addItem("Dash Dot", Qt.DashDotLine)
        self.penStyleComboBox.addItem("Dash Dot Dot", Qt.DashDotDotLine)
        self.penStyleComboBox.addItem("None", Qt.NoPen)

        penStyleLabel = QLabel("&Pen Style:")
        penStyleLabel.setBuddy(self.penStyleComboBox)

        self.penCapComboBox = QComboBox()
        self.penCapComboBox.addItem("Flat", Qt.FlatCap)
        self.penCapComboBox.addItem("Square", Qt.SquareCap)
        self.penCapComboBox.addItem("Round", Qt.RoundCap)

        penCapLabel = QLabel("Pen &Cap:")
        penCapLabel.setBuddy(self.penCapComboBox)

        self.penJoinComboBox = QComboBox()
        self.penJoinComboBox.addItem("Miter", Qt.MiterJoin)
        self.penJoinComboBox.addItem("Bevel", Qt.BevelJoin)
        self.penJoinComboBox.addItem("Round", Qt.RoundJoin)

        penJoinLabel = QLabel("Pen &Join:")
        penJoinLabel.setBuddy(self.penJoinComboBox)

        self.brushStyleComboBox = QComboBox()
        self.brushStyleComboBox.addItem("Linear Gradient",
                Qt.LinearGradientPattern)
        self.brushStyleComboBox.addItem("Radial Gradient",
                Qt.RadialGradientPattern)
        self.brushStyleComboBox.addItem("Conical Gradient",
                Qt.ConicalGradientPattern)
        self.brushStyleComboBox.addItem("Texture", Qt.TexturePattern)
        self.brushStyleComboBox.addItem("Solid", Qt.SolidPattern)
        self.brushStyleComboBox.addItem("Horizontal", Qt.HorPattern)
        self.brushStyleComboBox.addItem("Vertical", Qt.VerPattern)
        self.brushStyleComboBox.addItem("Cross", Qt.CrossPattern)
        self.brushStyleComboBox.addItem("Backward Diagonal", Qt.BDiagPattern)
        self.brushStyleComboBox.addItem("Forward Diagonal", Qt.FDiagPattern)
        self.brushStyleComboBox.addItem("Diagonal Cross", Qt.DiagCrossPattern)
        self.brushStyleComboBox.addItem("Dense 1", Qt.Dense1Pattern)
        self.brushStyleComboBox.addItem("Dense 2", Qt.Dense2Pattern)
        self.brushStyleComboBox.addItem("Dense 3", Qt.Dense3Pattern)
        self.brushStyleComboBox.addItem("Dense 4", Qt.Dense4Pattern)
        self.brushStyleComboBox.addItem("Dense 5", Qt.Dense5Pattern)
        self.brushStyleComboBox.addItem("Dense 6", Qt.Dense6Pattern)
        self.brushStyleComboBox.addItem("Dense 7", Qt.Dense7Pattern)
        self.brushStyleComboBox.addItem("None", Qt.NoBrush)

        brushStyleLabel = QLabel("&Brush Style:")
        brushStyleLabel.setBuddy(self.brushStyleComboBox)

        otherOptionsLabel = QLabel("Other Options:")
        self.antialiasingCheckBox = QCheckBox("&Antialiasing")
        self.transformationsCheckBox = QCheckBox("&Transformations")

        self.shapeComboBox.activated.connect(self.shapeChanged)
        self.penWidthSpinBox.valueChanged.connect(self.penChanged)
        self.penStyleComboBox.activated.connect(self.penChanged)
        self.penCapComboBox.activated.connect(self.penChanged)
        self.penJoinComboBox.activated.connect(self.penChanged)
        self.brushStyleComboBox.activated.connect(self.brushChanged)
        self.antialiasingCheckBox.toggled.connect(self.renderArea.setAntialiased)
        self.transformationsCheckBox.toggled.connect(self.renderArea.setTransformed)

        mainLayout = QGridLayout()
        mainLayout.setColumnStretch(0, 1)
        mainLayout.setColumnStretch(3, 1)
        mainLayout.addWidget(self.renderArea, 0, 0, 1, 4)
        mainLayout.setRowMinimumHeight(1, 6)
        mainLayout.addWidget(shapeLabel, 2, 1, Qt.AlignRight)
        mainLayout.addWidget(self.shapeComboBox, 2, 2)
        mainLayout.addWidget(penWidthLabel, 3, 1, Qt.AlignRight)
        mainLayout.addWidget(self.penWidthSpinBox, 3, 2)
        mainLayout.addWidget(penStyleLabel, 4, 1, Qt.AlignRight)
        mainLayout.addWidget(self.penStyleComboBox, 4, 2)
        mainLayout.addWidget(penCapLabel, 5, 1, Qt.AlignRight)
        mainLayout.addWidget(self.penCapComboBox, 5, 2)
        mainLayout.addWidget(penJoinLabel, 6, 1, Qt.AlignRight)
        mainLayout.addWidget(self.penJoinComboBox, 6, 2)
        mainLayout.addWidget(brushStyleLabel, 7, 1, Qt.AlignRight)
        mainLayout.addWidget(self.brushStyleComboBox, 7, 2)
        mainLayout.setRowMinimumHeight(8, 6)
        mainLayout.addWidget(otherOptionsLabel, 9, 1, Qt.AlignRight)
        mainLayout.addWidget(self.antialiasingCheckBox, 9, 2)
        mainLayout.addWidget(self.transformationsCheckBox, 10, 2)
        self.setLayout(mainLayout)

        self.shapeChanged()
        self.penChanged()
        self.brushChanged()
        self.antialiasingCheckBox.setChecked(True)

        self.setWindowTitle("Basic Drawing")

    def shapeChanged(self):
        shape = self.shapeComboBox.itemData(self.shapeComboBox.currentIndex(),
                IdRole)
        self.renderArea.setShape(shape)

    def penChanged(self):
        width = self.penWidthSpinBox.value()
        style = Qt.PenStyle(self.penStyleComboBox.itemData(
                self.penStyleComboBox.currentIndex(), IdRole))
        cap = Qt.PenCapStyle(self.penCapComboBox.itemData(
                self.penCapComboBox.currentIndex(), IdRole))
        join = Qt.PenJoinStyle(self.penJoinComboBox.itemData(
                self.penJoinComboBox.currentIndex(), IdRole))

        self.renderArea.setPen(QPen(Qt.blue, width, style, cap, join))

    def brushChanged(self):
        style = Qt.BrushStyle(self.brushStyleComboBox.itemData(
                self.brushStyleComboBox.currentIndex(), IdRole))

        if style == Qt.LinearGradientPattern:
            linearGradient = QLinearGradient(0, 0, 100, 100)
            linearGradient.setColorAt(0.0, Qt.white)
            linearGradient.setColorAt(0.2, Qt.green)
            linearGradient.setColorAt(1.0, Qt.black)
            self.renderArea.setBrush(QBrush(linearGradient))
        elif style == Qt.RadialGradientPattern:
            radialGradient = QRadialGradient(50, 50, 50, 70, 70)
            radialGradient.setColorAt(0.0, Qt.white)
            radialGradient.setColorAt(0.2, Qt.green)
            radialGradient.setColorAt(1.0, Qt.black)
            self.renderArea.setBrush(QBrush(radialGradient))
        elif style == Qt.ConicalGradientPattern:
            conicalGradient = QConicalGradient(50, 50, 150)
            conicalGradient.setColorAt(0.0, Qt.white)
            conicalGradient.setColorAt(0.2, Qt.green)
            conicalGradient.setColorAt(1.0, Qt.black)
            self.renderArea.setBrush(QBrush(conicalGradient))
        elif style == Qt.TexturePattern:
            self.renderArea.setBrush(QBrush(QPixmap(':/images/brick.png')))
        else:
            self.renderArea.setBrush(QBrush(Qt.green, style))