def __init__(self, cp: ControlPoint, game_model: GameModel): super().__init__(self) self.cp = cp self.game_model = game_model self.bought_amount_labels = {} self.existing_units_labels = {} main_layout = QVBoxLayout() self.setLayout(main_layout) scroll_content = QWidget() task_box_layout = QGridLayout() scroll_content.setLayout(task_box_layout) units_column = sorted(cp.base.armor, key=lambda u: u.name) count = 0 for count, unit_type in enumerate(units_column): self.add_purchase_row(unit_type, task_box_layout, count) stretch = QVBoxLayout() stretch.addStretch() task_box_layout.addLayout(stretch, count, 0) scroll_content.setLayout(task_box_layout) scroll = QScrollArea() scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll.setWidgetResizable(True) scroll.setWidget(scroll_content) main_layout.addWidget(scroll)
def init_ui(self): self.mainLayout = QVBoxLayout() scroll_content = QWidget() task_box_layout = QGridLayout() scroll_content.setLayout(task_box_layout) for g in self.cp.ground_objects: # Airbase groups are the objects that are hidden on the map because # they're shown in the base menu. if not g.airbase_group: continue # Of these, we need to ignore the FOB structure itself since that's # not supposed to be targetable. if isinstance(self.cp, Fob) and isinstance(g, BuildingGroundObject): continue group_info = QBaseDefenseGroupInfo(self.cp, g, self.game) task_box_layout.addWidget(group_info) scroll_content.setLayout(task_box_layout) scroll = QScrollArea() scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll.setWidgetResizable(True) scroll.setWidget(scroll_content) self.mainLayout.addWidget(scroll) self.setLayout(self.mainLayout)
def init_ui(self): main_layout = QVBoxLayout() units = { CAP: db.find_unittype(CAP, self.game.player_name), CAS: db.find_unittype(CAS, self.game.player_name), } scroll_content = QWidget() task_box_layout = QGridLayout() row = 0 for task_type in units.keys(): units_column = list(set(units[task_type])) if len(units_column) == 0: continue units_column.sort(key=lambda x: db.PRICES[x]) for unit_type in units_column: if self.cp.is_carrier and not unit_type in db.CARRIER_CAPABLE: continue if self.cp.is_lha and not unit_type in db.LHA_CAPABLE: continue row = self.add_purchase_row(unit_type, task_box_layout, row) stretch = QVBoxLayout() stretch.addStretch() task_box_layout.addLayout(stretch, row, 0) scroll_content.setLayout(task_box_layout) scroll = QScrollArea() scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll.setWidgetResizable(True) scroll.setWidget(scroll_content) main_layout.addWidget(scroll) self.setLayout(main_layout)
class __Tab(QWidget): """ This code is for showing device specific items. This is just a scrollable display area. """ def __init__(self): self.logger = logging.getLogger(__name__) self.logger.debug("Initializing") super().__init__() self.setLayout(QVBoxLayout()) self.__scroll_area = QScrollArea(self) size_policy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum) size_policy.setHorizontalStretch(0) size_policy.setVerticalStretch(0) size_policy.setHeightForWidth( self.__scroll_area.hasHeightForWidth()) self.__scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) self.__scroll_area.setHorizontalScrollBarPolicy( Qt.ScrollBarAsNeeded) self.__scroll_area.setSizeAdjustPolicy( QAbstractScrollArea.AdjustToContents) self.__scroll_area.setSizePolicy(size_policy) self.__scroll_area.setWidgetResizable(True) self.layout().addWidget(self.__scroll_area) self.logger.debug("Initialized") def add_contents(self, contents): self.logger.debug("running") self.__scroll_area.setWidget(contents) self.logger.debug("done")
class PlayersWidget(QWidget): def __init__(self): factory = ApiRequestFactory.get_instance() QWidget.__init__(self) page_list = factory.get_players_from_page(1) self.layout = QVBoxLayout() label_widget = QWidget() label_widget.layout = QVBoxLayout() for page_obj in page_list[0]: for pl in page_obj[1]: lb_text = pl.first_name + ' ' + pl.last_name if pl.position is not None and (pl.position is not '' or pl.position is not ' '): lb_text = lb_text + ': ' + pl.position player_lb = QLabel(text=lb_text) label_widget.layout.addWidget(player_lb) label_widget.setLayout(label_widget.layout) self.scroll_widget = QScrollArea() self.scroll_widget.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) self.scroll_widget.setBackgroundRole(QPalette.Light) self.scroll_widget.setWidgetResizable(True) self.scroll_widget.setWidget(label_widget) self.layout.addWidget(self.scroll_widget) self.setLayout(self.layout)
def __init__(self, cp: ControlPoint, game_model: GameModel) -> None: super().__init__() self.cp = cp self.game_model = game_model self.transfers: Dict[Type[UnitType, int]] = defaultdict(int) main_layout = QVBoxLayout() scroll_content = QWidget() task_box_layout = QGridLayout() unit_types = set( self.game_model.game.faction_for(player=True).ground_units) sorted_units = sorted( {u for u in unit_types if self.cp.base.total_units_of_type(u)}, key=lambda u: u.name, ) for row, unit_type in enumerate(sorted_units): self.add_unit_row(unit_type, task_box_layout, row) stretch = QVBoxLayout() stretch.addStretch() task_box_layout.addLayout(stretch, task_box_layout.count(), 0) scroll_content.setLayout(task_box_layout) scroll = QScrollArea() scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll.setWidgetResizable(True) scroll.setWidget(scroll_content) main_layout.addWidget(scroll) self.setLayout(main_layout)
def init_ui(self): main_layout = QVBoxLayout() units = { PinpointStrike: db.find_unittype(PinpointStrike, self.game.player_name), } scroll_content = QWidget() task_box_layout = QGridLayout() scroll_content.setLayout(task_box_layout) row = 0 for task_type in units.keys(): units_column = list(set(units[task_type])) if len(units_column) == 0: continue units_column.sort(key=lambda x: db.PRICES[x]) for unit_type in units_column: row = self.add_purchase_row(unit_type, task_box_layout, row) stretch = QVBoxLayout() stretch.addStretch() task_box_layout.addLayout(stretch, row, 0) scroll_content.setLayout(task_box_layout) scroll = QScrollArea() scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll.setWidgetResizable(True) scroll.setWidget(scroll_content) main_layout.addWidget(scroll) self.setLayout(main_layout)
def _init_widgets(self): if self._state.am_none(): return layout = QVBoxLayout() area = QScrollArea() area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded) area.setWidgetResizable(True) table = QTableWidget(0, 0) table.setColumnCount(len(self.COLUMNS)) table.setHorizontalHeaderLabels(self.COLUMNS) self.table = table layout.addWidget(table) # common ones layout.setSpacing(0) layout.addStretch(0) layout.setContentsMargins(2, 2, 2, 2) # the container container = QFrame() container.setAutoFillBackground(True) palette = container.palette() palette.setColor(container.backgroundRole(), Qt.white) container.setPalette(palette) container.setLayout(layout) area.setWidget(container) base_layout = QVBoxLayout() base_layout.addWidget(area) self.setLayout(base_layout)
def __init__(self, cp: ControlPoint, game_model: GameModel): super().__init__() self.cp = cp self.setMinimumWidth(500) layout = QVBoxLayout() self.setLayout(layout) scroll_content = QWidget() task_box_layout = QGridLayout() scroll_content.setLayout(task_box_layout) for convoy in game_model.game.coalition_for( cp.captured).transfers.convoys.departing_from(cp): group_info = DepartingConvoyInfo(convoy) task_box_layout.addWidget(group_info) for cargo_ship in game_model.game.coalition_for( cp.captured).transfers.cargo_ships.departing_from(cp): group_info = DepartingConvoyInfo(cargo_ship) task_box_layout.addWidget(group_info) scroll_content.setLayout(task_box_layout) scroll = QScrollArea() scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll.setWidgetResizable(True) scroll.setWidget(scroll_content) layout.addWidget(scroll)
def _init_widgets(self): layout = QVBoxLayout() # address lbl_addr = QLabel() lbl_addr.setText("Address") txt_addr = QLineEdit() txt_addr.returnPressed.connect(self._on_address_entered) self._txt_addr = txt_addr top_layout = QHBoxLayout() top_layout.addWidget(lbl_addr) top_layout.addWidget(txt_addr) self._view = QMemoryView(self.state, self.workspace) area = QScrollArea() self._scrollarea = area area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded) area.setWidgetResizable(True) area.setWidget(self._view) layout.addLayout(top_layout) layout.addWidget(area) layout.setContentsMargins(0, 0, 0, 0) self.setLayout(layout)
def init_ui(self): main_layout = QVBoxLayout() scroll_content = QWidget() task_box_layout = QGridLayout() scroll_content.setLayout(task_box_layout) row = 0 unit_types = list( set(self.game_model.game.faction_for(player=True).ground_units)) unit_types.sort(key=lambda u: u.name) for row, unit_type in enumerate(unit_types): self.add_purchase_row(unit_type, task_box_layout, row) stretch = QVBoxLayout() stretch.addStretch() task_box_layout.addLayout(stretch, row, 0) scroll_content.setLayout(task_box_layout) scroll = QScrollArea() scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll.setWidgetResizable(True) scroll.setWidget(scroll_content) main_layout.addWidget(scroll) self.setLayout(main_layout)
class PageAllegroMonitored(QWidget): def __init__(self, parent=None, shared_dict=None): QWidget.__init__(self) parent.addWidget(self) self.shared_dict = shared_dict self.parent = parent self.setLayoutDirection(Qt.LeftToRight) self.gridLayout = QGridLayout(self) self.gridLayout.setContentsMargins(0, 0, 0, 0) self.scrollArea = QScrollArea(self) self.scrollArea.setStyleSheet("""QScrollArea{border: none;}""") self.scrollArea.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) self.scrollArea.setSizeAdjustPolicy(QAbstractScrollArea.AdjustIgnored) self.scrollArea.setWidgetResizable(True) self.gridLayout.addWidget(self.scrollArea, 0, 0, 1, 1) self.scrollAreaWidgetContents = QWidget() self.scrollAreaWidgetContents.setGeometry(QRect(0, 0, 654, 479)) self.scrollArea.setWidget(self.scrollAreaWidgetContents) self.gridLayout_scroll_area = QGridLayout( self.scrollAreaWidgetContents) self.gridLayout_scroll_area.setSpacing(0) self.gridLayout_scroll_area.setContentsMargins(40, 0, 40, -1) self.label_title = QLabel("List of your monitored objects", self.scrollAreaWidgetContents) self.label_title.setStyleSheet(styles.label_title) self.label_title.setAlignment(Qt.AlignCenter) self.gridLayout_scroll_area.addWidget(self.label_title) self.spacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding) self.load_list() def load_list(self): elements = data.read_monitored_elements() for element in elements: e = ElementAllegroMonitored(element['name'], element['link'], element['is_done'], element['price'], element['xpath'], element['time'], element['is_monitoring'], self.scrollAreaWidgetContents, self.shared_dict) self.gridLayout_scroll_area.addWidget(e) self.gridLayout_scroll_area.addItem(self.spacer) def add_to_list(self, name, link, is_done, price, xpath, time, is_monitoring): self.gridLayout_scroll_area.removeItem(self.spacer) e = ElementAllegroMonitored(name, link, is_done, price, xpath, time, is_monitoring) self.gridLayout_scroll_area.addWidget(e) self.gridLayout_scroll_area.addItem(self.spacer)
def _askForFieldsDialog(self, options, fields_type="inputs"): #Display a dialog to ask the user to choose what inputs/outputs they want dialog = QDialog(self) dialog.setWindowTitle(f"Select the model {fields_type.upper()}") dialogButtons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) dialogButtons.button(QDialogButtonBox.Ok).setDisabled(0) dialogButtons.accepted.connect(dialog.accept) dialogButtons.rejected.connect(dialog.reject) mainLayout = QVBoxLayout(dialog) scroll = QScrollArea(dialog) scroll.setWidgetResizable(True) layoutWidget = QWidget() layout = QVBoxLayout(layoutWidget) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) scroll.setWidget(layoutWidget) chosenFields=[] checkboxes=[] def handleCheckboxClicked(): dialogButtons.button(QDialogButtonBox.Ok).setDisabled(1) count = 0 for checkbox in checkboxes: if checkbox.isChecked(): count += 1 if fields_type.lower() == "output": setDisabled = True if count > 1 else False else: setDisabled = True if count == 0 else False dialogButtons.button(QDialogButtonBox.Ok).setDisabled(setDisabled) for input in options: checkbox = QCheckBox(text=input) checkbox.clicked.connect(handleCheckboxClicked) checkbox.setChecked(True) checkboxes.append(checkbox) layout.addWidget(checkbox) mainLayout.addWidget(QLabel(text=f"Please select the {fields_type.lower()} from the following:")) mainLayout.addWidget(scroll) mainLayout.addWidget(dialogButtons) dialog.setLayout(mainLayout) handleCheckboxClicked() if dialog.exec_() == QDialog.Accepted: for checkbox in checkboxes: if checkbox.isChecked(): chosenFields.append(checkbox.text()) self.logger.log(f"The chosen {fields_type.lower()} are: "+ ', '.join(chosenFields), type ="INFO") return chosenFields else: return []
def _init_widgets(self): if self._state.am_none(): return if self._state.arch.name not in self.ARCH_REGISTERS: l.error( "Architecture %s is not listed in QRegisterViewer.ARCH_REGISTERS.", self._state.arch.name) return layout = QVBoxLayout() area = QScrollArea() area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded) area.setWidgetResizable(True) regs = self.ARCH_REGISTERS[self._state.arch.name] # common ones common_regs = regs['common'] for reg_name in common_regs: sublayout = QHBoxLayout() lbl_reg_name = QLabel(self) lbl_reg_name.setProperty('class', 'reg_viewer_label') lbl_reg_name.setText(reg_name) lbl_reg_name.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) sublayout.addWidget(lbl_reg_name) sublayout.addSpacing(10) reg_value = QASTViewer(None, parent=self, workspace=self.workspace) self._registers[reg_name] = reg_value sublayout.addWidget(reg_value) layout.addLayout(sublayout) layout.setSpacing(0) layout.addStretch(0) layout.setContentsMargins(2, 2, 2, 2) # the container container = QFrame() container.setAutoFillBackground(True) palette = container.palette() palette.setColor(container.backgroundRole(), Qt.white) container.setPalette(palette) container.setLayout(layout) area.setWidget(container) base_layout = QVBoxLayout() base_layout.addWidget(area) self.setLayout(base_layout)
def _init_widgets(self): area = QScrollArea() area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded) area.setWidgetResizable(True) self._area = area base_layout = QVBoxLayout() base_layout.addWidget(area) self.setLayout(base_layout)
def __init__(self, cp: ControlPoint, game_model: GameModel) -> None: QFrame.__init__(self) self.cp = cp self.game_model = game_model self.purchase_groups = {} self.bought_amount_labels = {} self.existing_units_labels = {} # Determine maximum number of aircrafts that can be bought self.set_maximum_units(self.cp.total_aircraft_parking) self.bought_amount_labels = {} self.existing_units_labels = {} self.hangar_status = QHangarStatus(game_model, self.cp) main_layout = QVBoxLayout() scroll_content = QWidget() task_box_layout = QGridLayout() row = 0 unit_types: Set[AircraftType] = set() for unit_type in self.game_model.game.player_faction.aircrafts: if self.cp.is_carrier and not unit_type.carrier_capable: continue if self.cp.is_lha and not unit_type.lha_capable: continue if (self.cp.cptype in [ControlPointType.FOB, ControlPointType.FARP] and unit_type not in helicopter_map.values()): continue unit_types.add(unit_type) sorted_units = sorted( unit_types, key=lambda u: u.name, ) for row, unit_type in enumerate(sorted_units): self.add_purchase_row(unit_type, task_box_layout, row) stretch = QVBoxLayout() stretch.addStretch() task_box_layout.addLayout(stretch, row, 0) scroll_content.setLayout(task_box_layout) scroll = QScrollArea() scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll.setWidgetResizable(True) scroll.setWidget(scroll_content) main_layout.addLayout(self.hangar_status) main_layout.addWidget(scroll) self.setLayout(main_layout)
def init_ui(self): layout = QVBoxLayout() scroll_content = QWidget() intelLayout = QVBoxLayout() units = { CAP: db.find_unittype(CAP, self.game.enemy_name), Embarking: db.find_unittype(Embarking, self.game.enemy_name), CAS: db.find_unittype(CAS, self.game.enemy_name), PinpointStrike: db.find_unittype(PinpointStrike, self.game.enemy_name), } for task_type in units.keys(): units_column = list(set(units[task_type])) if sum([self.cp.base.total_units_of_type(u) for u in units_column]) > 0: group = QGroupBox(db.task_name(task_type)) groupLayout = QGridLayout() group.setLayout(groupLayout) row = 0 for unit_type in units_column: existing_units = self.cp.base.total_units_of_type(unit_type) if existing_units == 0: continue groupLayout.addWidget( QLabel( "<b>" + db.unit_get_expanded_info( self.game.enemy_country, unit_type, "name" ) + "</b>" ), row, 0, ) groupLayout.addWidget(QLabel(str(existing_units)), row, 1) row += 1 intelLayout.addWidget(group) scroll_content.setLayout(intelLayout) scroll = QScrollArea() scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll.setWidgetResizable(True) scroll.setWidget(scroll_content) layout.addWidget(scroll) self.setLayout(layout)
def init_ui(self): main_layout = QVBoxLayout() tasks = [CAP, CAS, AWACS] scroll_content = QWidget() task_box_layout = QGridLayout() row = 0 unit_types: Set[Type[FlyingType]] = set() for task in tasks: units = db.find_unittype(task, self.game_model.game.player_name) if not units: continue for unit in units: if not issubclass(unit, FlyingType): continue if self.cp.is_carrier and unit not in db.CARRIER_CAPABLE: continue if self.cp.is_lha and unit not in db.LHA_CAPABLE: continue if (self.cp.cptype in [ControlPointType.FOB, ControlPointType.FARP] and unit not in helicopter_map.values()): continue unit_types.add(unit) sorted_units = sorted( unit_types, key=lambda u: db.unit_get_expanded_info( self.game_model.game.player_country, u, "name"), ) for unit_type in sorted_units: row = self.add_purchase_row( unit_type, task_box_layout, row, disabled=not self.cp.can_operate(unit_type), ) stretch = QVBoxLayout() stretch.addStretch() task_box_layout.addLayout(stretch, row, 0) scroll_content.setLayout(task_box_layout) scroll = QScrollArea() scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll.setWidgetResizable(True) scroll.setWidget(scroll_content) main_layout.addLayout(self.hangar_status) main_layout.addWidget(scroll) self.setLayout(main_layout)
class SearchRouteList(QWidget): def __init__(self, routes): super().__init__() self.route_list = RouteList(routes) self.scroll_area = QScrollArea() self.scroll_area.setWidget(self.route_list) self.scroll_area.setWidgetResizable(False) self.scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) self.search_line = QLineEdit() self.search_line.setPlaceholderText('Search') self.search_line.textChanged.connect(self.search) self.search_line.returnPressed.connect(self.select_first_visible) layout = QVBoxLayout() layout.addWidget(self.search_line) layout.addWidget(self.scroll_area) self.setLayout(layout) def search(self): text_elements = self.search_line.text().lower().split(' ') for button in self.route_list.buttons: visible = all(text_element in button.text().lower() for text_element in text_elements) button.setVisible(visible) def select_first_visible(self): for button in self.route_list.buttons: if button.isVisible(): button.animateClick() return def select_route_with_name(self, name): for route, button in self.route_list.route_per_button.items(): if route.name == name: button.animateClick() return def set_search(self, text): self.search_line.setText(text) def current_search(self): return self.search_line.text() def focus(self): self.search_line.setFocus() self.search_line.selectAll()
def __init__(self, cp: ControlPoint): super(QIntelInfo, self).__init__() self.cp = cp layout = QVBoxLayout() scroll_content = QWidget() intel_layout = QVBoxLayout() units_by_task: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int)) for unit_type, count in self.cp.allocated_aircraft().present.items(): if count: task_type = unit_type.dcs_unit_type.task_default.name units_by_task[task_type][unit_type.name] += count units_by_task = { task: units_by_task[task] for task in sorted(units_by_task.keys()) } front_line_units = defaultdict(int) for unit_type, count in self.cp.base.armor.items(): if count: front_line_units[unit_type.name] += count units_by_task["Front line units"] = front_line_units for task, unit_types in units_by_task.items(): task_group = QGroupBox(task) task_layout = QGridLayout() task_group.setLayout(task_layout) for row, (name, count) in enumerate(unit_types.items()): task_layout.addWidget(QLabel(f"<b>{name}</b>"), row, 0) task_layout.addWidget(QLabel(str(count)), row, 1) intel_layout.addWidget(task_group) scroll_content.setLayout(intel_layout) scroll = QScrollArea() scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll.setWidgetResizable(True) scroll.setWidget(scroll_content) layout.addWidget(scroll) self.setLayout(layout)
def __init__(self, squadrons: list[Squadron], theater: ConflictTheater) -> None: super().__init__() layout = QVBoxLayout() self.setLayout(layout) self.squadrons_config = SquadronConfigurationLayout(squadrons, theater) self.squadrons_config.config_changed.connect( self.on_squadron_config_changed) scrolling_widget = QWidget() scrolling_widget.setLayout(self.squadrons_config) scrolling_area = QScrollArea() scrolling_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scrolling_area.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scrolling_area.setWidgetResizable(True) scrolling_area.setWidget(scrolling_widget) layout.addWidget(scrolling_area)
def init_ui(self): self.mainLayout = QVBoxLayout() scroll_content = QWidget() task_box_layout = QGridLayout() scroll_content.setLayout(task_box_layout) for g in self.cp.ground_objects: if g.airbase_group: group_info = QBaseDefenseGroupInfo(self.cp, g, self.game) task_box_layout.addWidget(group_info) scroll_content.setLayout(task_box_layout) scroll = QScrollArea() scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll.setWidgetResizable(True) scroll.setWidget(scroll_content) self.mainLayout.addWidget(scroll) self.setLayout(self.mainLayout)
def build_ui(self): layout = QGridLayout(self) layout.setContentsMargins(5, 5, 5, 5) self.setLayout(layout) self.name_edt = QLineEdit() self.name_edt.setPlaceholderText('Create New') self.name_edt.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) layout.addWidget(self.name_edt, 0, 0, 1, 1) self.add_btn = QPushButton() self.add_btn.setIcon(QIcon(QPixmap(':/teAdditive.png'))) self.add_btn.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Preferred) layout.addWidget(self.add_btn, 0, 1, 1, 1) self.refresh_btn = QPushButton() self.refresh_btn.setIcon(QIcon(QPixmap(':/teKeyRefresh.png'))) self.refresh_btn.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Preferred) layout.addWidget(self.refresh_btn, 0, 2, 1, 1) scroll_wdg = QWidget(self) scroll_area = QScrollArea() scroll_area.setWidgetResizable(True) scroll_area.setStyleSheet( "QScrollArea { background-color: rgb(57,57,57);}") scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll_area.setWidget(scroll_wdg) self.spore_layout = QVBoxLayout() self.spore_layout.setContentsMargins(1, 1, 3, 1) self.spore_layout.setSpacing(0) self.spore_layout.addStretch() scroll_wdg.setLayout(self.spore_layout) layout.addWidget(scroll_area, 1, 0, 1, 3)
def __init__(self, cp: ControlPoint, game_model: GameModel): super().__init__( game_model, GroundUnitPurchaseAdapter( cp, game_model.game.coalition_for(cp.captured), game_model.game), ) self.cp = cp self.game_model = game_model self.purchase_groups = {} self.bought_amount_labels = {} self.existing_units_labels = {} main_layout = QVBoxLayout() scroll_content = QWidget() task_box_layout = QGridLayout() scroll_content.setLayout(task_box_layout) row = 0 unit_types = list( set(self.game_model.game.faction_for(player=True).ground_units)) unit_types.sort(key=lambda u: u.name) for row, unit_type in enumerate(unit_types): self.add_purchase_row(unit_type, task_box_layout, row) stretch = QVBoxLayout() stretch.addStretch() task_box_layout.addLayout(stretch, row, 0) scroll_content.setLayout(task_box_layout) scroll = QScrollArea() scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll.setWidgetResizable(True) scroll.setWidget(scroll_content) main_layout.addWidget(scroll) self.setLayout(main_layout)
def init_ui(self): main_layout = QVBoxLayout() tasks = [CAP, CAS] scroll_content = QWidget() task_box_layout = QGridLayout() row = 0 unit_types: Set[UnitType] = set() for task in tasks: units = db.find_unittype(task, self.game_model.game.player_name) if not units: continue for unit in units: if self.cp.is_carrier and unit not in db.CARRIER_CAPABLE: continue if self.cp.is_lha and unit not in db.LHA_CAPABLE: continue unit_types.add(unit) sorted_units = sorted(unit_types, key=lambda u: db.unit_type_name_2(u)) for unit_type in sorted_units: row = self.add_purchase_row(unit_type, task_box_layout, row) stretch = QVBoxLayout() stretch.addStretch() task_box_layout.addLayout(stretch, row, 0) scroll_content.setLayout(task_box_layout) scroll = QScrollArea() scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll.setWidgetResizable(True) scroll.setWidget(scroll_content) main_layout.addLayout(self.hangar_status) main_layout.addWidget(scroll) self.setLayout(main_layout)
class NodeChoiceWidget(QWidget): def __init__(self, flow, nodes): super(NodeChoiceWidget, self).__init__() self.flow = flow self.all_nodes = sort_nodes(nodes) # copy, no ref self.nodes = [] # 'current_nodes' are the currently selectable ones, they get recreated every time update_view() is called self.current_nodes = [] self.all_current_node_widgets = [] self.active_node_widget_index = -1 self.active_node_widget = None self.reset_list() self.node_widget_index_counter = 0 self.setMinimumWidth(260) self.setFixedHeight(450) self.main_layout = QVBoxLayout(self) self.main_layout.setAlignment(Qt.AlignTop) self.setLayout(self.main_layout) # adding all stuff to the layout self.search_line_edit = QLineEdit(self) self.search_line_edit.setPlaceholderText('search for node...') self.search_line_edit.textChanged.connect(self.update_view) self.layout().addWidget(self.search_line_edit) self.list_scroll_area = QScrollArea(self) self.list_scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) self.list_scroll_area.setHorizontalScrollBarPolicy( Qt.ScrollBarAsNeeded) self.list_scroll_area.setWidgetResizable(True) self.list_scroll_area_widget = QWidget() self.list_scroll_area.setWidget(self.list_scroll_area_widget) self.list_layout = QVBoxLayout() self.list_layout.setAlignment(Qt.AlignTop) self.list_scroll_area_widget.setLayout(self.list_layout) self.layout().addWidget(self.list_scroll_area) self.setFixedHeight(400) self.update_view('') try: f = open('resources/stylesheets/dark_node_choice_widget.txt') self.setStyleSheet(f.read()) f.close() except FileNotFoundError: pass self.search_line_edit.setFocus() def mousePressEvent(self, event): QWidget.mousePressEvent(self, event) event.accept() def keyPressEvent(self, event): if event.key() == Qt.Key_Escape: self.flow.hide_node_choice_widget() if event.key() == Qt.Key_Down: index = self.active_node_widget_index+1 if \ self.active_node_widget_index+1 < len(self.all_current_node_widgets) else 0 self.set_active_node_widget_index(index) if event.key() == Qt.Key_Up: index = self.active_node_widget_index-1 if \ self.active_node_widget_index-1 > -1 else len(self.all_current_node_widgets)-1 self.set_active_node_widget_index(index) if event.key() == Qt.Key_Return: if len(self.all_current_node_widgets) > 0: self.place_node(self.active_node_widget_index) def wheelEvent(self, event): QWidget.wheelEvent(self, event) event.accept() def refocus(self): self.search_line_edit.setFocus() self.search_line_edit.selectAll() def update_list(self, nodes): self.nodes = sort_nodes(nodes) def reset_list(self): self.nodes = self.all_nodes def update_view(self, text=''): text = text.lower() for i in reversed(range(self.list_layout.count())): self.list_layout.itemAt(i).widget().setParent(None) self.current_nodes.clear() self.all_current_node_widgets.clear() self.node_widget_index_counter = 0 # select valid elements from text # nodes nodes_names_dict = {} for n in self.nodes: nodes_names_dict[n] = n.title.lower() sorted_indices = self.get_sorted_dict_matching_search( nodes_names_dict, text) for n, index in sorted_indices.items(): self.current_nodes.append(n) # nodes if len(self.current_nodes) > 0: nodes_label = QLabel('Hover for description') nodes_label_font = QFont('Poppins') nodes_label_font.setPixelSize(15) nodes_label.setStyleSheet('color: #9bbf9dff; border: none;') nodes_label.setFont(nodes_label_font) self.list_layout.addWidget(nodes_label) for n in self.current_nodes: node_widget = self.create_list_item_widget(n) self.list_layout.addWidget(node_widget) self.all_current_node_widgets.append(node_widget) if len(self.all_current_node_widgets) > 0: self.set_active_node_widget_index(0) # self.setFixedWidth(self.minimumWidth()) # print(self.list_scroll_area_widget.width()) def get_sorted_dict_matching_search(self, items_dict, text): indices_dict = {} for item, name in items_dict.items( ): # the strings are already lowered here Debugger.debug(item, name, text) if name.__contains__(text): index = name.index(text) indices_dict[item] = index return { k: v for k, v in sorted(indices_dict.items(), key=lambda i: i[1]) } def create_list_item_widget(self, node): node_widget = NodeWidget(self, node) # , self.node_images[node]) node_widget.custom_focused_from_inside.connect( self.node_widget_focused_from_inside) node_widget.setObjectName('node_widget_' + str(self.node_widget_index_counter)) self.node_widget_index_counter += 1 node_widget.chosen.connect(self.node_widget_chosen) return node_widget def node_widget_focused_from_inside(self): self.set_active_node_widget_index( self.all_current_node_widgets.index(self.sender())) def set_active_node_widget_index(self, index): self.active_node_widget_index = index node_widget = self.all_current_node_widgets[index] if self.active_node_widget: self.active_node_widget.set_custom_focus(False) node_widget.set_custom_focus(True) self.active_node_widget = node_widget self.list_scroll_area.ensureWidgetVisible(self.active_node_widget) def node_widget_chosen( self ): # gets called when the user clicks on a node widget with the mouse self.flow.ignore_mouse_event = True # otherwise, it will receive a mouse press event index = int( self.sender().objectName()[self.sender().objectName().rindex('_') + 1:]) self.place_node(index) def place_node(self, index): node_index = index node = self.current_nodes[node_index] self.flow.place_node__cmd(node) self.flow.hide_node_choice_widget()
def __init__(self, filenames: list, *args, **kwargs): super(ImportParamDialog, self).__init__(*args, **kwargs) self.import_widgets = [] self.setWindowTitle("Video Import Options") self.import_types = [ { "video_type": "hdf5", "match": "h5,hdf5", "video_class": Video.from_hdf5, "params": [ { "name": "dataset", "type": "function_menu", "options": "_get_h5_dataset_options", "required": True, }, { "name": "input_format", "type": "radio", "options": "channels_first,channels_last", "required": True, # we can't currently auto-detect }, ], }, { "video_type": "mp4", "match": "mp4,avi", "video_class": Video.from_media, "params": [{ "name": "grayscale", "type": "check" }], }, { "video_type": "imgstore", "match": "json", "video_class": Video.from_filename, "params": [], }, ] outer_layout = QVBoxLayout() scroll_widget = QScrollArea() # scroll_widget.setWidgetResizable(False) scroll_widget.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) scroll_widget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll_items_widget = QWidget() scroll_layout = QVBoxLayout() for file_name in filenames: if file_name: this_type = None for import_type in self.import_types: if import_type.get("match", None) is not None: if file_name.lower().endswith( tuple(import_type["match"].split(","))): this_type = import_type break if this_type is not None: import_item_widget = ImportItemWidget(file_name, this_type) self.import_widgets.append(import_item_widget) scroll_layout.addWidget(import_item_widget) else: raise Exception("No match found for file type.") scroll_items_widget.setLayout(scroll_layout) scroll_widget.setWidget(scroll_items_widget) outer_layout.addWidget(scroll_widget) button_layout = QHBoxLayout() cancel_button = QPushButton("Cancel") import_button = QPushButton("Import") import_button.setDefault(True) button_layout.addStretch() button_layout.addWidget(cancel_button) button_layout.addWidget(import_button) outer_layout.addLayout(button_layout) self.setLayout(outer_layout) import_button.clicked.connect(self.accept) cancel_button.clicked.connect(self.reject)
def _startButtonClicked(self): self.logger.log("Attempting to start the processing", type="INFO") if not self.b_serialConnected: self.logger.log( "Serial is not connected, Please connect serial first", type="ERROR") return if self.inputLineEdit.text()[-4:].lower() != ".csv": self.logger.log("Please select a valid input csv file", type="ERROR") return if self.outputFolderLineEdit.text() == "": self.logger.log("Please select an output directory", type="ERROR") return self.executer = Executer(serialObj=self.port, loggerObj=self.logger) if self.modelLineEdit.text() != "": modelPath = self.modelLineEdit.text() else: modelPath = None if self._modelRPiPath: self.logger.log( "Please select a valid model that is already available in the folder saved_models on the RPi", type="ERROR") return #Read the Input File try: inputDataFrame = pd.read_csv(self.inputLineEdit.text()) except: self.logger.log("CSV File Reading Failed, select a valid csv file", type="ERROR") possibleInputs = list(inputDataFrame.columns) #Display a dialog to ask the user to choose what inputs they want dialog = QDialog(self) dialog.setWindowTitle("Select the Input Fields") dialogButtons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) dialogButtons.button(QDialogButtonBox.Ok).setDisabled(0) dialogButtons.accepted.connect(dialog.accept) dialogButtons.rejected.connect(dialog.reject) mainLayout = QVBoxLayout(dialog) scroll = QScrollArea(dialog) scroll.setWidgetResizable(True) layoutWidget = QWidget() layout = QVBoxLayout(layoutWidget) scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) scroll.setWidget(layoutWidget) chosenInputs = [] checkboxes = [] def handleCheckboxClicked(): dialogButtons.button(QDialogButtonBox.Ok).setDisabled(1) for checkbox in checkboxes: if checkbox.isChecked(): dialogButtons.button(QDialogButtonBox.Ok).setDisabled(0) for input in possibleInputs: checkbox = QCheckBox(text=input) checkbox.clicked.connect(handleCheckboxClicked) checkbox.setChecked(True) checkboxes.append(checkbox) layout.addWidget(checkbox) mainLayout.addWidget( QLabel(text="Please select the input fields from the following:")) mainLayout.addWidget(scroll) mainLayout.addWidget(dialogButtons) dialog.setLayout(mainLayout) # dialog.setFixedHeight(400) if dialog.exec_() == QDialog.Accepted: for checkbox in checkboxes: if checkbox.isChecked(): chosenInputs.append(checkbox.text()) self.logger.log("The chosen input fields are: " + ', '.join(chosenInputs), type="INFO") else: return self.startStopButton.setText("Stop Processing") self.b_processRunning = True executionResult = self.executer.execute(self.labNameComboBox.currentText().split(":")[0], inputDataFrame, \ self.outputFolderLineEdit.text(), inputFields=chosenInputs, progressBar=self.progressBar, \ model=modelPath if not self._modelRPiPath else "RPI:"+modelPath) if executionResult == ExecutionResult.COMPLETED: self._stopButtonClicked(finishedProcessing=True) elif executionResult == ExecutionResult.INTERRUPTED or executionResult == ExecutionResult.FAILED: self._stopButtonClicked() if self.executer.reset() == ExecutionResult.FAILED: self.logger.log( "Resetting the serial state of RPi Failed, please power cycle the RPi", type="ERROR") else: self.logger.log("The serial state of RPi has been reset", type="INFO")
class QImageFlowWidget(_ViewModelWidgetBase, Generic[TImageFlowView, TImageFlowModel]): def __init__(self, parent): # type: (QObject) -> NoReturn super(QImageFlowWidget, self).__init__(parent, QImageFlowView, QImageFlowModel) self.__scrollArea = QScrollArea() self.__scrollArea.setWidgetResizable(True) self.__scrollArea.setWidget(self._view) mainLayout = QHBoxLayout() mainLayout.setContentsMargins(0, 0, 0, 0) mainLayout.addWidget(self.__scrollArea) self.setLayout(mainLayout) self.__flowDirection = self.setFlowDirection( QFlowDirection.LeftToRight) def setFlowDirection(self, direction): # type: (str) -> str if direction == QFlowDirection.LeftToRight: self.view().setFlow(QListView.LeftToRight) self.__scrollArea.setHorizontalScrollBarPolicy( Qt.ScrollBarAlwaysOff) self.__scrollArea.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) return direction if direction == QFlowDirection.TopToBottom: self.view().setFlow(QListView.TopToBottom) self.__scrollArea.setHorizontalScrollBarPolicy( Qt.ScrollBarAsNeeded) self.__scrollArea.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) return direction def flowDirection(self): # type: () -> str return self.__flowDirection def setProxyModel(self, proxy): # type: (QAbstractProxyModel) -> NoReturn model = self.model() if isinstance(model, QAbstractProxyModel): proxy.setSourceModel(model.sourceModel()) model.deleteLater() else: proxy.setSourceModel(model) self.view().setModel(proxy) def appendItem(self, item): # type: (TImageFlowItem) -> TImageFlowItem model = self.model() if isinstance(model, QAbstractProxyModel): model = model.sourceModel() model.append(item) return item def appendImage(self, image): # type: (QImage) -> TImageFlowItem item = QImageFlowItem() item.setImage(image) return self.appendItem(item) def appendFile(self, filePath): # type: (str) -> TImageFlowItem image = QImage(filePath) return self.appendImage(image)
class SlideShow(QObject): current_index_changed = Signal(int) clicked = Signal() key_pressed = Signal(QEvent) def __init__(self, parent, base_widget, is_animated=True): QObject.__init__(self, parent) self._base_widget = base_widget # has to be stacked widget self._is_animated = is_animated self._slides_count = self._base_widget.count() self._scroll_area = QScrollArea(parent) self._scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self._scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self._scroll_area.setFrameShape(QFrame.NoFrame) self._scroll_area.mouseReleaseEvent = self._on_mouse_release_event self._scroll_area.keyPressEvent = self._on_key_pressed self._slide_width = None self._current_index = 0 self._is_moving = False self._orig_resize_event = self._base_widget.resizeEvent self._base_widget.resizeEvent = self._resizeEvent self._animation_time = 300 self._animation_steps = 50 def _construct_ribbon(self): self._ribbon = QWidget() self._layout = QHBoxLayout() self._ribbon.setLayout(self._layout) x = 0 for i in range(self._slides_count): self._base_widget.setCurrentIndex(i) widget = self._base_widget.currentWidget() if widget: new_widget = self._grab(widget) self._layout.addWidget(new_widget) x += self._slide_width def _grab(self, widget): new_widget = QLabel() pixmap = widget.grab() new_widget.setPixmap(pixmap) return new_widget def _resizeEvent(self, *args, **kwargs): self._orig_resize_event(*args, **kwargs) if not self._slide_width: self._scroll_area.setGeometry(self._base_widget.geometry()) self._slide_width = self._base_widget.widget(0).width() QTimer.singleShot(50, self._show) def _show(self): self._construct_ribbon() self._scroll_area.setWidget(self._ribbon) self._scroll_area.setAlignment(Qt.AlignCenter) self._scroll_area.show() self._scroll_area.setFocus() def _on_mouse_release_event(self, ev): self.clicked.emit() def _on_key_pressed(self, ev): self.key_pressed.emit(ev) def setAnimated(self, is_animated, animation_time=None, animation_steps=None): self._is_animated = is_animated if animation_time: self._animation_time = animation_time if animation_steps: self._animation_steps = animation_steps def is_moving(self): return self._is_moving def setCurrentIndex(self, new_index): new_index = max(new_index, 0) new_index = min(new_index, self._slides_count - 1) if new_index == self._current_index or self._is_moving: return is_animated = self._is_animated and \ abs(self._current_index - new_index) == 1 self._move(new_index, is_animated) def _move(self, new_index, is_animated): self._is_moving = True source_x = self._current_index * self._slide_width target_x = new_index * self._slide_width if not is_animated: dx = target_x - source_x self._ribbon.scroll(-dx, 0) self._finish_moving(new_index) else: animation_interval = self._animation_time // self._animation_steps dx = (target_x - source_x) // self._animation_steps self._move_animated(source_x, target_x, dx, animation_interval, new_index) def _move_animated(self, source_x, target_x, dx, animation_interval, new_index): if target_x == source_x: self._finish_moving(new_index) return if target_x > source_x: dx = min(dx, target_x - source_x) else: dx = -min(-dx, source_x - target_x) self._ribbon.scroll(-dx, 0) source_x += dx QTimer.singleShot( animation_interval, lambda: self._move_animated( source_x, target_x, dx, animation_interval, new_index)) def _finish_moving(self, new_index): self._current_index = new_index self.current_index_changed.emit(self._current_index) self._is_moving = False def widget(self): return self._scroll_area