Coverage for paintmaskanimator/color_chart.py: 43%

1"""Editable colour-chart window and Paint Mask Group (``.pmag``) data. 

2 

3The chart is deliberately separate from the live used-colour list. It stores 

4planned parent/child relationships and role tags, then applies only the colours 

5that actually exist in the current document when the user asks it to. 

6""" 

7from __future__ import annotations 

8 

9import copy 

10import json 

11import math 

12import re 

13from pathlib import Path 

14 

15from PySide6.QtCore import QEvent, QMimeData, QPointF, QRectF, QSize, Qt, Signal 

16from PySide6.QtGui import QColor, QDrag, QPainter, QPen 

17from PySide6.QtWidgets import ( 

18 QComboBox, 

19 QDialog, 

20 QDialogButtonBox, 

21 QFormLayout, 

22 QHBoxLayout, 

23 QLabel, 

24 QLineEdit, 

25 QListWidget, 

26 QListWidgetItem, 

27 QMessageBox, 

28 QPushButton, 

29 QScrollArea, 

30 QSizePolicy, 

31 QToolButton, 

32 QVBoxLayout, 

33 QWidget, 

34) 

35 

36from .errors import OperationError 

37from .i18n import tr 

38from .color_picker_dialog import ColorPickerDialog 

39 

40 

41PMAG_FORMAT = "PaintMaskGroup" 

42PMAG_VERSION = 1 

43MAX_CHART_TILES = 1024 

44MAX_CHART_CHILDREN = 4096 

45MAX_TAGS = 1024 

46TAG_MIME = "application/x-paintmaskanimator-color-tag" 

47 

48 

49def _hex_color(value): 

50 color = QColor(str(value or "")) 

51 if not color.isValid(): 

52 return None 

53 return color.name(QColor.NameFormat.HexRgb).upper() 

54 

55 

56def _tag(value): 

57 return str(value or "").strip()[:32] 

58 

59 

60def _unique_id(value, used, fallback_index): 

61 base = re.sub(r"[^A-Za-z0-9_-]+", "_", str(value or "")).strip("_") 

62 base = base[:64] or f"group_{fallback_index}" 

63 candidate = base 

64 suffix = 2 

65 while candidate in used: 65 ↛ 66line 65 didn't jump to line 66 because the condition on line 65 was never true

66 candidate = f"{base}_{suffix}" 

67 suffix += 1 

68 used.add(candidate) 

69 return candidate 

70 

71 

72def empty_color_chart(): 

73 return { 

74 "format": PMAG_FORMAT, 

75 "format_version": PMAG_VERSION, 

76 "groups": [], 

77 "parent_tags": [], 

78 "tag_library": ["Base"], 

79 "tag_colors": {"Base": "#FFFFFF"}, 

80 "group_names": {}, 

81 "tag_order": [], 

82 "tiles": [], 

83 } 

84 

85 

86def normalize_color_chart(data): 

87 """Return a bounded canonical chart, accepting every old PMAG variant.""" 

88 source = dict(data or {}) if isinstance(data, dict) else {} 

89 raw_colors = source.get("tag_colors", {}) 

90 tag_colors = {"Base": "#FFFFFF"} 

91 if isinstance(raw_colors, dict): 91 ↛ 98line 91 didn't jump to line 98 because the condition on line 91 was always true

92 for raw_name, raw_color in list(raw_colors.items())[:MAX_TAGS]: 

93 name = _tag(raw_name) 

94 color = _hex_color(raw_color) 

95 if name and color: 95 ↛ 92line 95 didn't jump to line 92 because the condition on line 95 was always true

96 tag_colors[name] = color 

97 

98 raw_library = source.get("tag_library", []) 

99 library = [] 

100 if isinstance(raw_library, list): 100 ↛ 105line 100 didn't jump to line 105 because the condition on line 100 was always true

101 for value in raw_library[:MAX_TAGS]: 

102 name = _tag(value) 

103 if name and name not in library: 103 ↛ 101line 103 didn't jump to line 101 because the condition on line 103 was always true

104 library.append(name) 

105 if "Base" in library: 105 ↛ 107line 105 didn't jump to line 107 because the condition on line 105 was always true

106 library.remove("Base") 

107 library.insert(0, "Base") 

108 

109 raw_order = source.get("tag_order", []) 

110 order = [] 

111 if isinstance(raw_order, list): 111 ↛ 117line 111 didn't jump to line 117 because the condition on line 111 was always true

112 for value in raw_order[:MAX_TAGS]: 

113 name = _tag(value) 

114 if name and name.casefold() != "base" and name not in order: 114 ↛ 112line 114 didn't jump to line 112 because the condition on line 114 was always true

115 order.append(name) 

116 

117 raw_tiles = source.get("tiles") 

118 tiles = [] 

119 used_ids = set() 

120 total_children = 0 

121 if isinstance(raw_tiles, list): 121 ↛ 164line 121 didn't jump to line 164 because the condition on line 121 was always true

122 for index, raw_tile in enumerate(raw_tiles[:MAX_CHART_TILES], 1): 

123 if not isinstance(raw_tile, dict): 123 ↛ 124line 123 didn't jump to line 124 because the condition on line 123 was never true

124 continue 

125 raw_parent = raw_tile.get("parent") 

126 if raw_parent is None: 126 ↛ 127line 126 didn't jump to line 127 because the condition on line 126 was never true

127 raw_parent = {} 

128 if not isinstance(raw_parent, dict): 128 ↛ 129line 128 didn't jump to line 129 because the condition on line 128 was never true

129 continue 

130 parent_color = _hex_color(raw_parent.get("color")) 

131 placeholder = bool(raw_tile.get("placeholder")) or parent_color is None 

132 parent_tag = "" if placeholder else (_tag(raw_parent.get("tag")) or "Base") 

133 children = [] 

134 seen_children = set() 

135 raw_children = raw_tile.get("children", []) 

136 if not isinstance(raw_children, list): 136 ↛ 137line 136 didn't jump to line 137 because the condition on line 136 was never true

137 raw_children = [] 

138 for raw_child in raw_children: 

139 if total_children >= MAX_CHART_CHILDREN: 139 ↛ 140line 139 didn't jump to line 140 because the condition on line 139 was never true

140 break 

141 if not isinstance(raw_child, dict): 141 ↛ 142line 141 didn't jump to line 142 because the condition on line 141 was never true

142 continue 

143 child_color = _hex_color(raw_child.get("color")) 

144 child_tag = _tag(raw_child.get("tag")) 

145 if not child_color or child_color in seen_children: 145 ↛ 146line 145 didn't jump to line 146 because the condition on line 145 was never true

146 continue 

147 if not placeholder and child_color == parent_color: 147 ↛ 148line 147 didn't jump to line 148 because the condition on line 147 was never true

148 continue 

149 children.append({"color": child_color, "tag": child_tag}) 

150 seen_children.add(child_color) 

151 total_children += 1 

152 if placeholder and not children: 152 ↛ 153line 152 didn't jump to line 153 because the condition on line 152 was never true

153 continue 

154 tile_id = _unique_id(raw_tile.get("id"), used_ids, index) 

155 tiles.append({ 

156 "id": tile_id, 

157 "name": str(raw_tile.get("name", "")).strip()[:64], 

158 "parent": {"color": None if placeholder else parent_color, "tag": parent_tag}, 

159 "placeholder": placeholder, 

160 "children": children, 

161 }) 

162 else: 

163 # Convert the original flat relationship representation. 

164 raw_groups = source.get("groups", []) 

165 if not isinstance(raw_groups, list): 

166 raw_groups = [] 

167 raw_parent_tags = source.get("parent_tags", []) 

168 if not isinstance(raw_parent_tags, list): 

169 raw_parent_tags = [] 

170 parent_tags = {} 

171 for entry in raw_parent_tags[:MAX_CHART_TILES]: 

172 if not isinstance(entry, dict): 

173 continue 

174 parent = _hex_color(entry.get("parent")) 

175 name = _tag(entry.get("tag")) 

176 if parent and name: 

177 parent_tags[parent] = name 

178 raw_names = source.get("group_names", {}) 

179 group_names = raw_names if isinstance(raw_names, dict) else {} 

180 by_parent = {} 

181 parent_order = [] 

182 for entry in raw_groups[:MAX_CHART_CHILDREN]: 

183 if not isinstance(entry, dict): 

184 continue 

185 parent = _hex_color(entry.get("parent")) 

186 child = _hex_color(entry.get("child")) 

187 if not parent or not child or parent == child: 

188 continue 

189 if parent not in by_parent: 

190 by_parent[parent] = [] 

191 parent_order.append(parent) 

192 if child not in {item["color"] for item in by_parent[parent]}: 

193 by_parent[parent].append({"color": child, "tag": _tag(entry.get("tag"))}) 

194 standalone = source.get("standalone", []) 

195 if not isinstance(standalone, list): 

196 standalone = [] 

197 for parent in parent_order: 

198 tile_id = _unique_id("", used_ids, len(tiles) + 1) 

199 tiles.append({ 

200 "id": tile_id, 

201 "name": str(group_names.get(parent, "")).strip()[:64], 

202 "parent": {"color": parent, "tag": parent_tags.get(parent, "Base")}, 

203 "placeholder": False, 

204 "children": by_parent[parent], 

205 }) 

206 for entry in standalone[:MAX_CHART_TILES - len(tiles)]: 

207 if not isinstance(entry, dict): 

208 continue 

209 color = _hex_color(entry.get("color")) 

210 if not color: 

211 continue 

212 tile_id = _unique_id("", used_ids, len(tiles) + 1) 

213 tiles.append({ 

214 "id": tile_id, 

215 "name": "", 

216 "parent": {"color": color, "tag": _tag(entry.get("tag")) or "Base"}, 

217 "placeholder": False, 

218 "children": [], 

219 }) 

220 

221 groups = [] 

222 parent_tags_out = [] 

223 group_names_out = {} 

224 seen_parent_tags = set() 

225 for tile in tiles: 

226 parent = tile["parent"]["color"] 

227 parent_tag = tile["parent"]["tag"] 

228 if parent: 

229 if tile["name"]: 

230 group_names_out[parent] = tile["name"] 

231 if parent_tag and parent not in seen_parent_tags: 231 ↛ 234line 231 didn't jump to line 234 because the condition on line 231 was always true

232 parent_tags_out.append({"parent": parent, "tag": parent_tag}) 

233 seen_parent_tags.add(parent) 

234 for child in tile["children"]: 

235 groups.append({ 

236 "child": child["color"], 

237 "parent": parent, 

238 "tag": child["tag"], 

239 }) 

240 if parent_tag and parent_tag not in library: 240 ↛ 241line 240 didn't jump to line 241 because the condition on line 240 was never true

241 library.append(parent_tag) 

242 for child in tile["children"]: 

243 name = child["tag"] 

244 if name and name not in library: 244 ↛ 245line 244 didn't jump to line 245 because the condition on line 244 was never true

245 library.append(name) 

246 

247 for name in list(tag_colors): 

248 if name not in library: 248 ↛ 249line 248 didn't jump to line 249 because the condition on line 248 was never true

249 library.append(name) 

250 for name in library: 

251 tag_colors.setdefault(name, "#FFFFFF" if name == "Base" else "#58667A") 

252 for name in library: 

253 if name.casefold() != "base" and name not in order: 253 ↛ 254line 253 didn't jump to line 254 because the condition on line 253 was never true

254 order.append(name) 

255 

256 return { 

257 "format": PMAG_FORMAT, 

258 "format_version": PMAG_VERSION, 

259 "groups": groups, 

260 "parent_tags": parent_tags_out, 

261 "tag_library": library[:MAX_TAGS], 

262 "tag_colors": {name: tag_colors[name] for name in library[:MAX_TAGS]}, 

263 "group_names": group_names_out, 

264 "tag_order": order[:MAX_TAGS], 

265 "tiles": tiles, 

266 } 

267 

268 

269def merge_color_charts(existing, current): 

270 """Append new palette relationships without losing earlier colour variants.""" 

271 old = normalize_color_chart(existing) 

272 new = normalize_color_chart(current) 

273 merged = copy.deepcopy(old) 

274 by_parent = { 

275 tile["parent"]["color"]: tile 

276 for tile in merged["tiles"] 

277 if not tile["placeholder"] and tile["parent"]["color"] 

278 } 

279 for source_tile in new["tiles"]: 

280 parent = source_tile["parent"]["color"] 

281 target = by_parent.get(parent) if parent else None 

282 if target is None: 

283 added = copy.deepcopy(source_tile) 

284 added["id"] = _unique_id( 

285 added.get("id"), {tile["id"] for tile in merged["tiles"]}, 

286 len(merged["tiles"]) + 1, 

287 ) 

288 merged["tiles"].append(added) 

289 if parent: 

290 by_parent[parent] = added 

291 continue 

292 existing_children = {child["color"] for child in target["children"]} 

293 for child in source_tile["children"]: 

294 if child["color"] not in existing_children: 

295 target["children"].append(copy.deepcopy(child)) 

296 existing_children.add(child["color"]) 

297 if source_tile["parent"]["tag"]: 

298 target["parent"]["tag"] = source_tile["parent"]["tag"] 

299 if source_tile["name"]: 

300 target["name"] = source_tile["name"] 

301 merged["tag_library"] = list(dict.fromkeys( 

302 [*old["tag_library"], *new["tag_library"]] 

303 )) 

304 merged["tag_colors"] = {**old["tag_colors"], **new["tag_colors"]} 

305 merged["tag_order"] = list(dict.fromkeys( 

306 [*old["tag_order"], *new["tag_order"]] 

307 )) 

308 return normalize_color_chart(merged) 

309 

310 

311def _tile(chart, group_id): 

312 return next((item for item in chart["tiles"] if item["id"] == group_id), None) 

313 

314 

315def move_chart_color(data, source_hit, target_hit=None): 

316 """Move one colour occurrence between chart tiles and return a new chart.""" 

317 chart = normalize_color_chart(data) 

318 source = _tile(chart, source_hit.get("group_id")) 

319 if source is None: 319 ↛ 320line 319 didn't jump to line 320 because the condition on line 319 was never true

320 return chart, False 

321 role = source_hit.get("role") 

322 if role == "parent": 

323 if source.get("placeholder"): 323 ↛ 324line 323 didn't jump to line 324 because the condition on line 323 was never true

324 return chart, False 

325 moved = dict(source["parent"]) 

326 if source["children"]: 326 ↛ 330line 326 didn't jump to line 330 because the condition on line 326 was always true

327 source["parent"] = {"color": None, "tag": ""} 

328 source["placeholder"] = True 

329 else: 

330 chart["tiles"].remove(source) 

331 elif role == "child": 331 ↛ 339line 331 didn't jump to line 339 because the condition on line 331 was always true

332 index = int(source_hit.get("index", -1)) 

333 if index < 0 or index >= len(source["children"]): 333 ↛ 334line 333 didn't jump to line 334 because the condition on line 333 was never true

334 return chart, False 

335 moved = source["children"].pop(index) 

336 if source.get("placeholder") and not source["children"]: 336 ↛ 337line 336 didn't jump to line 337 because the condition on line 336 was never true

337 chart["tiles"].remove(source) 

338 else: 

339 return chart, False 

340 

341 target = _tile(chart, target_hit.get("group_id")) if target_hit else None 

342 if target is None or target_hit is None: 

343 used = {item["id"] for item in chart["tiles"]} 

344 chart["tiles"].append({ 

345 "id": _unique_id("", used, len(chart["tiles"]) + 1), 

346 "name": "", 

347 "parent": { 

348 "color": moved["color"], 

349 "tag": moved.get("tag") or "Base", 

350 }, 

351 "placeholder": False, 

352 "children": [], 

353 }) 

354 return normalize_color_chart(chart), True 

355 

356 target_role = target_hit.get("role") 

357 if target_role == "parent" and target.get("placeholder"): 357 ↛ 366line 357 didn't jump to line 366 because the condition on line 357 was always true

358 target["parent"] = { 

359 "color": moved["color"], 

360 "tag": moved.get("tag") or "Base", 

361 } 

362 target["placeholder"] = False 

363 else: 

364 # A parent dropped on another group becomes a child. Base describes a 

365 # parent role, so do not carry it into a child role. 

366 child = { 

367 "color": moved["color"], 

368 "tag": "" if moved.get("tag") == "Base" else moved.get("tag", ""), 

369 } 

370 target["children"] = [ 

371 item for item in target["children"] 

372 if item["color"] != child["color"] 

373 ] 

374 if target_role == "child": 

375 insert_at = max(0, min( 

376 int(target_hit.get("index", len(target["children"]))), 

377 len(target["children"]), 

378 )) 

379 target["children"].insert(insert_at, child) 

380 else: 

381 target["children"].append(child) 

382 return normalize_color_chart(chart), True 

383 

384 

385def assign_chart_tag(data, hit, tag_name): 

386 chart = normalize_color_chart(data) 

387 tile = _tile(chart, hit.get("group_id")) 

388 name = _tag(tag_name) 

389 if tile is None or (hit.get("role") == "parent" and tile.get("placeholder")): 

390 return chart, False 

391 if hit.get("role") == "parent": 

392 tile["parent"]["tag"] = name or "Base" 

393 elif hit.get("role") == "child": 

394 index = int(hit.get("index", -1)) 

395 if index < 0 or index >= len(tile["children"]): 

396 return chart, False 

397 tile["children"][index]["tag"] = name 

398 else: 

399 return chart, False 

400 if name and name not in chart["tag_library"]: 

401 chart["tag_library"].append(name) 

402 chart["tag_colors"][name] = "#58667A" 

403 return normalize_color_chart(chart), True 

404 

405 

406class ColorTagDialog(QDialog): 

407 def __init__(self, name="", color="#58667A", *, lock_name=False, parent=None): 

408 super().__init__(parent) 

409 self.setWindowTitle(tr("カラーチャートのタグ")) 

410 self._color = QColor(color) 

411 if not self._color.isValid(): 

412 self._color = QColor("#58667A") 

413 layout = QVBoxLayout(self) 

414 form = QFormLayout() 

415 self.name_edit = QLineEdit(str(name)) 

416 self.name_edit.setMaxLength(32) 

417 self.name_edit.setEnabled(not lock_name) 

418 self.color_button = QPushButton() 

419 self.color_button.clicked.connect(self._choose_color) 

420 self._refresh_color_button() 

421 form.addRow(tr("タグ名"), self.name_edit) 

422 form.addRow(tr("タグ色"), self.color_button) 

423 layout.addLayout(form) 

424 buttons = QDialogButtonBox( 

425 QDialogButtonBox.StandardButton.Ok 

426 | QDialogButtonBox.StandardButton.Cancel 

427 ) 

428 buttons.accepted.connect(self.accept) 

429 buttons.rejected.connect(self.reject) 

430 layout.addWidget(buttons) 

431 

432 def _choose_color(self): 

433 def apply(color): 

434 self._color = QColor(color) 

435 self._refresh_color_button() 

436 

437 color = ColorPickerDialog.get_color( 

438 self._color, self, tr("タグ色"), preview=apply 

439 ) 

440 if color.isValid(): 

441 apply(color) 

442 

443 def _refresh_color_button(self): 

444 value = self._color.name(QColor.NameFormat.HexRgb).upper() 

445 self.color_button.setText(value) 

446 self.color_button.setStyleSheet(f"background:{value};") 

447 

448 def values(self): 

449 return _tag(self.name_edit.text()), self._color.name( 

450 QColor.NameFormat.HexRgb 

451 ).upper() 

452 

453 

454class TagListWidget(QListWidget): 

455 orderChanged = Signal(object) 

456 

457 def __init__(self, parent=None): 

458 super().__init__(parent) 

459 self.setDragEnabled(True) 

460 self.setAcceptDrops(True) 

461 self.setDropIndicatorShown(True) 

462 self.setSelectionMode(QListWidget.SelectionMode.SingleSelection) 

463 

464 def startDrag(self, _supported_actions): 

465 item = self.currentItem() 

466 if item is None: 

467 return 

468 mime = QMimeData() 

469 mime.setData(TAG_MIME, item.text().encode("utf-8")) 

470 drag = QDrag(self) 

471 drag.setMimeData(mime) 

472 drag.exec(Qt.DropAction.MoveAction | Qt.DropAction.CopyAction) 

473 

474 def dragEnterEvent(self, event): 

475 if event.mimeData().hasFormat(TAG_MIME): 

476 event.acceptProposedAction() 

477 return 

478 super().dragEnterEvent(event) 

479 

480 def dragMoveEvent(self, event): 

481 if event.mimeData().hasFormat(TAG_MIME): 

482 event.acceptProposedAction() 

483 return 

484 super().dragMoveEvent(event) 

485 

486 def dropEvent(self, event): 

487 if not event.mimeData().hasFormat(TAG_MIME): 

488 super().dropEvent(event) 

489 return 

490 name = bytes(event.mimeData().data(TAG_MIME)).decode("utf-8", "replace") 

491 source_row = next( 

492 (row for row in range(self.count()) if self.item(row).text() == name), 

493 -1, 

494 ) 

495 target_item = self.itemAt(event.position().toPoint()) 

496 target_row = self.row(target_item) if target_item is not None else self.count() 

497 if source_row > 0: # Base remains first. 

498 item = self.takeItem(source_row) 

499 if source_row < target_row: 

500 target_row -= 1 

501 self.insertItem(max(1, target_row), item) 

502 self.setCurrentItem(item) 

503 self.orderChanged.emit([ 

504 self.item(row).text() for row in range(1, self.count()) 

505 ]) 

506 event.acceptProposedAction() 

507 

508 

509class ColorChartCanvas(QWidget): 

510 colorPicked = Signal(QColor) 

511 tileMoveRequested = Signal(object, object) 

512 tagDropRequested = Signal(object, str) 

513 tileTagEditRequested = Signal(object) 

514 groupNameChanged = Signal(str, str) 

515 

516 TILE_WIDTH = 184 

517 TILE_HEIGHT = 112 

518 HEADER_HEIGHT = 24 

519 GAP = 8 

520 COLUMNS = 3 

521 

522 def __init__(self, parent=None): 

523 super().__init__(parent) 

524 self.chart = empty_color_chart() 

525 self.groups = [] 

526 self.zoom = 1.0 

527 self.scroll_area: QScrollArea | None = None 

528 self._color_hits = [] 

529 self._header_hits = [] 

530 self._drag_mode = "" 

531 self._drag_start = QPointF() 

532 self._drag_last = QPointF() 

533 self._drag_scroll = (0, 0) 

534 self._drag_zoom = 1.0 

535 self._pressed_hit = None 

536 self._space_down = False 

537 self._ctrl_down = False 

538 self._name_editor = None 

539 self.setFocusPolicy(Qt.FocusPolicy.StrongFocus) 

540 self.setMouseTracking(True) 

541 self.setAcceptDrops(True) 

542 self._update_canvas_size() 

543 self._update_mode_cursor() 

544 

545 def set_chart(self, chart): 

546 self.chart = normalize_color_chart(chart) 

547 rank = {name: index for index, name in enumerate(self.chart["tag_order"])} 

548 self.groups = [] 

549 for tile in self.chart["tiles"]: 

550 children = list(enumerate(tile["children"])) 

551 children.sort(key=lambda pair: ( 

552 rank.get(pair[1]["tag"], len(rank) + 1), 

553 pair[1]["tag"].casefold(), 

554 pair[1]["color"], 

555 )) 

556 self.groups.append({ 

557 "id": tile["id"], 

558 "name": tile["name"], 

559 "parent": tile["parent"]["color"], 

560 "parent_tag": tr("未設定") if tile["placeholder"] else tile["parent"]["tag"], 

561 "placeholder": tile["placeholder"], 

562 "children": children, 

563 }) 

564 self._update_canvas_size() 

565 self.update() 

566 

567 def _base_size(self): 

568 count = max(1, len(self.groups)) 

569 columns = min(self.COLUMNS, count) 

570 rows = max(1, int(math.ceil(count / self.COLUMNS))) 

571 return ( 

572 columns * self.TILE_WIDTH + (columns + 1) * self.GAP, 

573 rows * (self.HEADER_HEIGHT + self.TILE_HEIGHT) + (rows + 1) * self.GAP, 

574 ) 

575 

576 def _update_canvas_size(self): 

577 width, height = self._base_size() 

578 size = QSize(max(1, math.ceil(width * self.zoom)), max(1, math.ceil(height * self.zoom))) 

579 self.setMinimumSize(size) 

580 self.resize(size) 

581 

582 @staticmethod 

583 def _text_color(color): 

584 brightness = (color.red() * 299 + color.green() * 587 + color.blue() * 114) / 1000 

585 return QColor("#111111" if brightness >= 145 else "#FFFFFF") 

586 

587 @staticmethod 

588 def _draw_checker(painter, rect, size=10): 

589 left, top = int(rect.left()), int(rect.top()) 

590 right, bottom = int(math.ceil(rect.right())), int(math.ceil(rect.bottom())) 

591 for y in range(top, bottom, size): 

592 for x in range(left, right, size): 

593 color = QColor("#EEEEEE") if ((x - left) // size + (y - top) // size) % 2 == 0 else QColor("#B8B8B8") 

594 painter.fillRect(QRectF(x, y, size, size), color) 

595 

596 def paintEvent(self, _event): 

597 painter = QPainter(self) 

598 painter.setRenderHint(QPainter.RenderHint.Antialiasing, False) 

599 painter.scale(self.zoom, self.zoom) 

600 self._color_hits = [] 

601 self._header_hits = [] 

602 for position, group in enumerate(self.groups): 

603 row, column = divmod(position, self.COLUMNS) 

604 x = self.GAP + column * (self.TILE_WIDTH + self.GAP) 

605 y = self.GAP + row * (self.HEADER_HEIGHT + self.TILE_HEIGHT + self.GAP) 

606 header = QRectF(x, y, self.TILE_WIDTH, self.HEADER_HEIGHT) 

607 painter.fillRect(header, QColor("#E6E6E6")) 

608 painter.setPen(QColor("#777777")) 

609 painter.drawRect(header) 

610 painter.setPen(QColor("#222222")) 

611 painter.drawText( 

612 header.adjusted(4, 1, -4, -1), 

613 Qt.AlignmentFlag.AlignCenter, 

614 group["name"] or tr("（グループ名）"), 

615 ) 

616 self._header_hits.append({"rect": QRectF(header), "group_id": group["id"]}) 

617 

618 body_y = y + self.HEADER_HEIGHT 

619 parent_rect = QRectF(x, body_y, self.TILE_WIDTH / 2, self.TILE_HEIGHT) 

620 if group["placeholder"]: 

621 self._draw_checker(painter, parent_rect) 

622 parent_color = QColor("#C8C8C8") 

623 else: 

624 parent_color = QColor(group["parent"]) 

625 painter.fillRect(parent_rect, parent_color) 

626 painter.setPen(QPen(QColor(0, 0, 0, 110), 1)) 

627 painter.drawRect(parent_rect) 

628 painter.setPen(QColor("#303030") if group["placeholder"] else self._text_color(parent_color)) 

629 painter.drawText(parent_rect.adjusted(3, 3, -3, -3), Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextWordWrap, group["parent_tag"]) 

630 self._color_hits.append({ 

631 "rect": QRectF(parent_rect), "group_id": group["id"], 

632 "role": "parent", "index": -1, "color": group["parent"] or "", 

633 "tag": group["parent_tag"], 

634 }) 

635 

636 children = group["children"] 

637 child_height = self.TILE_HEIGHT / max(1, len(children)) 

638 for child_position, (source_index, child) in enumerate(children): 

639 rect = QRectF( 

640 x + self.TILE_WIDTH / 2, 

641 body_y + child_position * child_height, 

642 self.TILE_WIDTH / 2, 

643 child_height, 

644 ) 

645 color = QColor(child["color"]) 

646 painter.fillRect(rect, color) 

647 painter.setPen(QColor(0, 0, 0, 110)) 

648 painter.drawRect(rect) 

649 painter.setPen(self._text_color(color)) 

650 painter.drawText(rect.adjusted(3, 1, -3, -1), Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextWordWrap, child["tag"]) 

651 self._color_hits.append({ 

652 "rect": QRectF(rect), "group_id": group["id"],