def __init__(
self,
editable: t.Union[Editable, t.Mapping[str, t.Any]],
undo_stack: t.Optional[QUndoStack] = None,
) -> None:
super().__init__(
Context.get_undo_stack() if undo_stack is None else undo_stack)
self._loading_lock = threading.Lock()
self._loading_event = threading.Event()
self._loading = False
if isinstance(editable, Editable):
self._editable = editable
self._serialized = None
else:
self._editable = None
self._serialized = editable
self._layout = QtWidgets.QVBoxLayout(self)
self._layout.setContentsMargins(0, 0, 0, 0)
self._loading_label = None
if self._editable is None:
self._loading_label = QtWidgets.QLabel('Loading...')
self._loading_label.setAlignment(QtCore.Qt.AlignCenter)
self._layout.addWidget(self._loading_label)
self.editable_loaded.connect(self._on_loaded)
else:
self._layout.addWidget(self._editable)
self._editable.tab = self
self._editable.show()
def add_editable(self, editable: t.Union[Editable, t.Mapping[str, t.Any]],
meta: TabMeta) -> Tab:
tab = EditorTab(
editable,
editable.undo_stack
if isinstance(editable, Editable) else Context.get_undo_stack(),
)
self.addTab(tab, meta.truncated_name)
self._metas[tab] = meta
return tab
def new_draft(self, draft_id: str) -> None:
for editable, meta in self._metas.items():
if meta.key == draft_id:
self.setCurrentWidget(editable)
return
saved_draft = Context.saved_drafts.pop(draft_id, None)
self.setCurrentWidget(
self.add_editable(
(DraftView.load(saved_draft, Context.get_undo_stack())
if saved_draft is not None else DraftView(
DraftModel(draft_id),
Context.get_undo_stack(),
)),
TabMeta(
'some draft',
key=draft_id,
),
))
def __init__(self, draft_model: DraftModel):
super().__init__()
self._undo_stack = Context.get_undo_stack()
self._draft_model = draft_model
self._latest_meta_info = PickMetaInfo(draft_model)
self._head_meta_info = PickMetaInfo(draft_model)
self._head_meta_info.hide()
self._countdown = Countdown()
self._countdown.hide()
self._picking_info = QtWidgets.QLabel('')
self._picking_info.setSizePolicy(QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Fixed)
self._booster_scene = CubeScene(
mode=CubeEditMode.CLOSED,
scene_type=SceneType.BOOSTER,
)
self._booster_view = CubeView(
scene=self._booster_scene,
undo_stack=self._undo_stack,
cube_image_view=BoosterImageView(
self._undo_stack,
self._booster_scene,
self._draft_model,
),
)
layout = QtWidgets.QVBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
info_bar_layout = QtWidgets.QHBoxLayout()
info_bar_layout.setContentsMargins(0, 0, 0, 0)
info_bar_layout.addWidget(self._latest_meta_info)
info_bar_layout.addWidget(self._head_meta_info)
info_bar_layout.addStretch()
info_bar_layout.addWidget(self._picking_info)
info_bar_layout.addWidget(self._countdown)
layout.addLayout(info_bar_layout)
layout.addWidget(self._booster_view)
self._draft_model.new_head.connect(self._set_pick_point)
self._draft_model.picked.connect(self._on_picked)
self._draft_model.received_booster.connect(self._on_receive_booster)
self._draft_model.boosters_changed.connect(self._on_boosters_changed)
self._booster_view.cube_image_view.card_double_clicked.connect(
self._on_card_double_clicked)
def new_limited_deck(self, deck: LimitedDeck) -> None:
key = f'pool-deck-{deck.id}'
if self._check_for_key(key):
return
tab = self.add_editable(
DeckView(
DeckModel(
list(map(PhysicalCard.from_cubeable, deck.deck.maindeck)),
list(map(PhysicalCard.from_cubeable, deck.deck.sideboard)),
),
undo_stack=Context.get_undo_stack(),
),
TabMeta(
deck.name,
key=key,
),
)
self.setCurrentWidget(tab)
self._sort_opened_view(tab.editable)
def new_pool(self, pool: Cube, infinites: Infinites, key: str) -> None:
for tab, meta in self._metas.items():
if meta.key == key:
self.setCurrentWidget(tab)
return
tab = self.add_editable(
PoolView(
PoolModel(
list(map(PhysicalCard.from_cubeable, pool)),
infinites=infinites,
),
undo_stack=Context.get_undo_stack(),
),
TabMeta(
key,
key=key,
),
)
self.setCurrentWidget(tab)
self._sort_opened_view(tab.editable)
def __init__(self,
deck_scene: CubeScene,
*,
parent: t.Optional[QtWidgets.QWidget] = None) -> None:
super().__init__(parent)
self._deck_scene = deck_scene
self._undo_stack = Context.get_undo_stack()
self._hand_scene = CubeScene(
aligner_type=GridAligner,
mode=CubeEditMode.CLOSED,
scene_type=SceneType.SAMPLE_HAND,
)
self._hand_view = CubeView(self._hand_scene, self._undo_stack)
self._draw_hand_button = QtWidgets.QPushButton('Draw Hand')
self._draw_hand_button.clicked.connect(self.refresh)
self._create_shortcut(self.refresh, 'h')
self._draw_card_button = QtWidgets.QPushButton('Draw Card')
self._draw_card_button.clicked.connect(lambda: self.add_cubeables(1))
self._create_shortcut(self.add_cubeables, 'd')
layout = QtWidgets.QVBoxLayout(self)
control_bar = QtWidgets.QHBoxLayout()
control_bar.addWidget(self._draw_hand_button)
control_bar.addWidget(self._draw_card_button)
layout.addWidget(self._hand_view)
layout.addLayout(control_bar)
def __init__(self):
super().__init__()
self._match: t.Optional[ScheduledMatch] = None
self._participants_model = ListTableModel(ParticipantsSchema())
self._participants_view: ReadOnlyListTableView[
TournamentParticipant] = ReadOnlyListTableView()
self.setFocusProxy(self._participants_view)
self._participants_view.setModel(self._participants_model)
self._participants_view.item_selected.connect(
lambda p: Context.editor.open_limited_deck(p.deck.id))
self._name_label = QtWidgets.QLabel()
self._name_label.setSizePolicy(QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Fixed)
self._round_label = QtWidgets.QLabel()
self._round_label.setSizePolicy(QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Fixed)
self._deck_cache: t.MutableMapping[int, t.Optional[LimitedDeck]] = {}
self._deck_preview_model = DeckModel(mode=CubeEditMode.CLOSED)
self._deck_preview = DeckView(
self._deck_preview_model,
Context.get_undo_stack(),
)
self._no_preview_view = QtWidgets.QLabel('No preview selected')
self._no_preview_view.setAlignment(Qt.AlignCenter)
self._preview_unavailable_view = QtWidgets.QLabel(
'Preview unavailable')
self._preview_unavailable_view.setAlignment(Qt.AlignCenter)
self._preview_stack = QtWidgets.QStackedWidget()
self._preview_stack.addWidget(self._deck_preview)
self._preview_stack.addWidget(self._preview_unavailable_view)
self._preview_stack.addWidget(self._no_preview_view)
self._preview_stack.setCurrentWidget(self._no_preview_view)
self.preview_fetched.connect(self._on_retrieved_deck)
self._participants_view.current_item_changed.connect(
self._on_participant_selected)
self._open_button = QtWidgets.QPushButton('Open')
self._open_button.clicked.connect(self._on_open_clicked)
self._open_all_button = QtWidgets.QPushButton('Open All')
self._open_all_button.clicked.connect(self._on_open_all_clicked)
layout = QtWidgets.QVBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
top_bar = QtWidgets.QHBoxLayout()
top_bar.setContentsMargins(5, 0, 5, 0)
top_bar.addWidget(self._name_label)
top_bar.addStretch()
top_bar.addWidget(self._round_label)
splitter = QtWidgets.QSplitter(Qt.Horizontal)
participants_view = QtWidgets.QWidget()
participants_layout = QtWidgets.QVBoxLayout(participants_view)
participants_layout.setContentsMargins(0, 0, 0, 0)
participants_control_bar_layout = QtWidgets.QHBoxLayout()
participants_control_bar_layout.setContentsMargins(0, 0, 0, 0)
participants_control_bar_layout.addWidget(self._open_button)
participants_control_bar_layout.addWidget(self._open_all_button)
participants_layout.addWidget(self._participants_view)
participants_layout.addLayout(participants_control_bar_layout)
splitter.addWidget(participants_view)
splitter.addWidget(self._preview_stack)
layout.addLayout(top_bar)
layout.addWidget(splitter)
def load_editable(serialized: t.Mapping[str, t.Any],
undo_stack: t.Optional[QUndoStack] = None) -> Editable:
return (PoolView if serialized['tab_type'] == TabType.POOL else
DeckView).load(serialized, undo_stack or Context.get_undo_stack())
def open_file(self, path: str, target: t.Type[TabModel] = Deck) -> None:
for editable, meta in self._metas.items():
if meta.path == path:
self.setCurrentWidget(editable)
return
file_name = os.path.split(path)[1]
name, extension = os.path.splitext(file_name)
extension = extension[1:]
meta = TabMeta(file_name, path)
editable = None
if extension.lower() == 'embd':
with open(path, 'rb') as f:
try:
tab = self.load_file(pickle.load(f), meta)
except UnpicklingError:
raise FileOpenException('corrupt file')
elif extension.lower() == 'embp':
with open(path, 'rb') as f:
try:
tab = self.load_file(pickle.load(f), meta)
except UnpicklingError:
raise FileOpenException('corrupt file')
else:
with open(path, 'r') as f:
try:
serializer: TabModelSerializer[t.Union[
Deck,
Pool]] = TabModelSerializer.extension_to_serializer[(
extension, target)]
except KeyError:
raise FileOpenException(
'unsupported file type "{}"'.format(extension))
try:
tab_model = serializer.deserialize(f.read())
except SerializationException:
raise FileOpenException()
if target == Deck:
editable = DeckView(
DeckModel(
list(
map(PhysicalCard.from_cubeable,
tab_model.maindeck)),
list(
map(PhysicalCard.from_cubeable,
tab_model.sideboard)),
),
Context.get_undo_stack(),
)
elif target == Pool:
editable = PoolView(
PoolModel(list(map(PhysicalCard.from_cubeable,
tab_model)), ),
Context.get_undo_stack(),
)
else:
raise FileOpenException(
'invalid load target "{}"'.format(target))
tab = self.add_editable(editable, meta)
self.setCurrentWidget(tab)
if editable is not None:
self._sort_opened_view(editable)
if not Context.main_window.isActiveWindow() and Context.settings.value(
'focus_on_open_file', True, bool):
Context.main_window.raise_()
Context.main_window.show()
Context.main_window.activateWindow()
def new_deck(self, model: DeckModel) -> Tab:
return self.add_editable(
DeckView(model, Context.get_undo_stack()),
TabMeta('untitled deck'),
)