"
+ return style
+
+def p_repl_func(matched, color):
+ style = ""
+ return style
+
+def set_html_color(html, rgb):
+ hex_color = '#%02x%02x%02x' % (rgb[0], rgb[1], rgb[2])
+ html = fragment_pattern.sub('', html)
+ html = p_pattern.sub(lambda matched: p_repl_func(matched, hex_color), html)
+ if color_pattern.findall(html):
+ return color_pattern.sub(f'color:{hex_color};', html)
+ else:
+ return span_pattern.sub(lambda matched: span_repl_func(matched, hex_color), html)
+
+def set_html_family(html, family):
+ return ffamily_pattern.sub(f'font-family:\'{family}\'', html)
+
+def html_max_fontsize(html: str) -> float:
+ size_list = fontsize_pattern.findall(html)
+ size_list = [float(size) for size in size_list]
+ if len(size_list) > 0:
+ return max(size_list)
+ else:
+ return None
+
+def doc_replace(doc: QTextDocument, span_list: List, target: str) -> List:
+ len_replace = len(target)
+ cursor = QTextCursor(doc)
+ cursor.setPosition(0)
+ cursor.beginEditBlock()
+ pos_delta = 0
+ sel_list = []
+ for span in span_list:
+ sel_start = span[0] + pos_delta
+ sel_end = span[1] + pos_delta
+ cursor.setPosition(sel_start)
+ cursor.setPosition(sel_end, QTextCursor.MoveMode.KeepAnchor)
+ cursor.insertText(target)
+ sel_list.append([sel_start, sel_end])
+ pos_delta += len_replace - (sel_end - sel_start)
+ cursor.endEditBlock()
+ return sel_list
+
+def doc_replace_no_shift(doc: QTextDocument, span_list: List, target: str):
+ cursor = QTextCursor(doc)
+ cursor.setPosition(0)
+ cursor.beginEditBlock()
+ for span in span_list:
+ cursor.setPosition(span[0])
+ cursor.setPosition(span[1], QTextCursor.MoveMode.KeepAnchor)
+ cursor.insertText(target)
+ cursor.endEditBlock()
+
+def hex2rgb(h: str): # rgb order (PIL)
+ return tuple(int(h[1 + i:1 + i + 2], 16) for i in (0, 2, 4))
+
+def parse_stylesheet(theme: str = '', reverse_icon: bool = False) -> str:
+ if reverse_icon:
+ dark2light = True if theme == 'eva-light' else False
+ reverse_icon_color(dark2light)
+ with open(C.STYLESHEET_PATH, "r", encoding='utf-8') as f:
+ stylesheet = f.read()
+ with open(C.THEME_PATH, 'r', encoding='utf8') as f:
+ theme_dict: Dict = json.loads(f.read())
+ if not theme or theme not in theme_dict:
+ tgt_theme: Dict = theme_dict[list(theme_dict.keys())[0]]
+ else:
+ tgt_theme: Dict = theme_dict[theme]
+
+ C.FOREGROUND_FONTCOLOR = hex2rgb(tgt_theme['@qwidgetForegroundColor'])
+ C.SLIDERHANDLE_COLOR = hex2rgb(tgt_theme['@sliderHandleColor'])
+ for key, val in tgt_theme.items():
+ stylesheet = stylesheet.replace(key, val)
+ return stylesheet
+
+
+ICON_DIR = 'icons'
+
+LIGHTFILL_ACTIVE = "fill=\"#697187\""
+LIGHTFILL = "fill=\"#b3b6bf\""
+DARKFILL_ACTIVE = "fill=\"#96a4cd\""
+DARKFILL = "fill=\"#697186\""
+
+ICONREVERSE_DICT_LIGHT2DARK = {LIGHTFILL_ACTIVE: DARKFILL_ACTIVE, LIGHTFILL: DARKFILL}
+ICONREVERSE_DICT_DARK2LIGHT = {DARKFILL_ACTIVE: LIGHTFILL_ACTIVE, DARKFILL: LIGHTFILL}
+ICON_LIST = []
+
+def reverse_icon_color(dark2light: bool = False):
+ global ICON_LIST
+ if not ICON_LIST:
+ for filename in os.listdir(ICON_DIR):
+ file_suffix = Path(filename).suffix
+ if file_suffix.lower() != '.svg':
+ continue
+ else:
+ ICON_LIST.append(osp.join(ICON_DIR, filename))
+
+ if dark2light:
+ pattern = re.compile(re.escape(DARKFILL) + '|' + re.escape(DARKFILL_ACTIVE))
+ rep_dict = ICONREVERSE_DICT_DARK2LIGHT
+ else:
+ pattern = re.compile(re.escape(LIGHTFILL) + '|' + re.escape(LIGHTFILL_ACTIVE))
+ rep_dict = ICONREVERSE_DICT_LIGHT2DARK
+ for svgpath in ICON_LIST:
+ with open(svgpath, "r", encoding="utf-8") as f:
+ svg_content = f.read()
+ svg_content = pattern.sub(lambda m:rep_dict[m.group()], svg_content)
+ with open(svgpath, "w", encoding="utf-8") as f:
+ f.write(svg_content)
+
+def mutate_dict_key(adict: dict, old_key: Union[str, int], new_key: str):
+ # https://stackoverflow.com/questions/12150872/change-key-in-ordereddict-without-losing-order
+ key_list = list(adict.keys())
+ if isinstance(old_key, int):
+ old_key = key_list[old_key]
+
+ for key in key_list:
+ value = adict.pop(key)
+ adict[new_key if old_key == key else key] = value
\ No newline at end of file
diff --git a/ui/module_manager.py b/ui/module_manager.py
new file mode 100644
index 0000000000000000000000000000000000000000..e9bfd2093f632db63324948b2b0e094823aaf1b9
--- /dev/null
+++ b/ui/module_manager.py
@@ -0,0 +1,881 @@
+import time
+from typing import Union, List, Dict, Callable
+import os.path as osp
+
+import numpy as np
+from qtpy.QtCore import QThread, Signal, QObject, QLocale, QTimer
+from qtpy.QtWidgets import QFileDialog
+
+from .funcmaps import get_maskseg_method
+from utils.logger import logger as LOGGER
+from utils.registry import Registry
+from utils.imgproc_utils import enlarge_window, get_block_mask
+from utils.io_utils import imread, text_is_empty
+from modules.translators import MissingTranslatorParams
+from modules.base import BaseModule, soft_empty_cache
+from modules import INPAINTERS, TRANSLATORS, TEXTDETECTORS, OCR, \
+ GET_VALID_TRANSLATORS, GET_VALID_TEXTDETECTORS, GET_VALID_INPAINTERS, GET_VALID_OCR, \
+ BaseTranslator, InpainterBase, TextDetectorBase, OCRBase, merge_config_module_params
+import modules
+modules.translators.SYSTEM_LANG = QLocale.system().name()
+from utils.textblock import TextBlock, sort_regions
+from utils import shared
+from utils.message import create_error_dialog, create_info_dialog
+from .custom_widget import ImgtransProgressMessageBox, ParamComboBox
+from .configpanel import ConfigPanel
+from utils.proj_imgtrans import ProjImgTrans
+from utils.config import pcfg
+cfg_module = pcfg.module
+
+
+class ModuleThread(QThread):
+
+ finish_set_module = Signal()
+ _failed_set_module_msg = 'Failed to set module.'
+
+ def __init__(self, module_key: str, MODULE_REGISTER: Registry, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+ self.job = None
+ self.module: Union[TextDetectorBase, BaseTranslator, InpainterBase, OCRBase] = None
+ self.module_register = MODULE_REGISTER
+ self.module_key = module_key
+
+ self.pipeline_pagekey_queue = []
+ self.finished_counter = 0
+ self.imgtrans_proj: ProjImgTrans = None
+
+ def _set_module(self, module_name: str):
+ old_module = self.module
+ try:
+ module: Union[TextDetectorBase, BaseTranslator, InpainterBase, OCRBase] \
+ = self.module_register.module_dict[module_name]
+ params = cfg_module.get_params(self.module_key)[module_name]
+ if params is not None:
+ self.module = module(**params)
+ else:
+ self.module = module()
+ if not pcfg.module.load_model_on_demand:
+ self.module.load_model()
+ if old_module is not None:
+ del old_module
+ except Exception as e:
+ self.module = old_module
+ create_error_dialog(e, self._failed_set_module_msg)
+
+ self.finish_set_module.emit()
+
+ def pipeline_finished(self):
+ if self.imgtrans_proj is None:
+ return True
+ elif self.finished_counter == len(self.imgtrans_proj.pages):
+ return True
+ return False
+
+ def initImgtransPipeline(self, proj: ProjImgTrans):
+ if self.isRunning():
+ self.terminate()
+ self.imgtrans_proj = proj
+ self.finished_counter = 0
+ self.pipeline_pagekey_queue.clear()
+
+ def run(self):
+ if self.job is not None:
+ self.job()
+ self.job = None
+
+
+class InpaintThread(ModuleThread):
+
+ finish_inpaint = Signal(dict)
+ inpainting = False
+ inpaint_failed = Signal()
+
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__('inpainter', INPAINTERS, *args, **kwargs)
+
+ @property
+ def inpainter(self) -> InpainterBase:
+ return self.module
+
+ def setInpainter(self, inpainter: str):
+ self.job = lambda : self._set_module(inpainter)
+ self.start()
+
+ def inpaint(self, img: np.ndarray, mask: np.ndarray, img_key: str = None, inpaint_rect=None):
+ self.job = lambda : self._inpaint(img, mask, img_key, inpaint_rect)
+ self.start()
+
+ def _inpaint(self, img: np.ndarray, mask: np.ndarray, img_key: str = None, inpaint_rect=None):
+ inpaint_dict = {}
+ self.inpainting = True
+ try:
+ inpainted = self.inpainter.inpaint(img, mask)
+ inpaint_dict = {
+ 'inpainted': inpainted,
+ 'img': img,
+ 'mask': mask,
+ 'img_key': img_key,
+ 'inpaint_rect': inpaint_rect
+ }
+ self.finish_inpaint.emit(inpaint_dict)
+ except Exception as e:
+ create_error_dialog(e, self.tr('Inpainting Failed.'), 'InpaintFailed')
+ self.inpainting = False
+ self.inpaint_failed.emit()
+ self.inpainting = False
+
+
+class TextDetectThread(ModuleThread):
+
+ finish_detect_page = Signal(str)
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__('textdetector', TEXTDETECTORS, *args, **kwargs)
+
+ def setTextDetector(self, textdetector: str):
+ self.job = lambda : self._set_module(textdetector)
+ self.start()
+
+ @property
+ def textdetector(self) -> TextDetectorBase:
+ return self.module
+
+
+class OCRThread(ModuleThread):
+
+ finish_ocr_page = Signal(str)
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__('ocr', OCR, *args, **kwargs)
+
+ def setOCR(self, ocr: str):
+ self.job = lambda : self._set_module(ocr)
+ self.start()
+
+ @property
+ def ocr(self) -> OCRBase:
+ return self.module
+
+
+class TranslateThread(ModuleThread):
+
+ finish_translate_page = Signal(str)
+ progress_changed = Signal(int)
+
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__('translator', TRANSLATORS, *args, **kwargs)
+ self.translator: BaseTranslator = self.module
+
+ def _set_translator(self, translator: str):
+
+ old_translator = self.translator
+ source, target = cfg_module.translate_source, cfg_module.translate_target
+ if self.translator is not None:
+ if self.translator.name == translator:
+ return
+
+ try:
+ params = cfg_module.translator_params[translator]
+ translator_module: BaseTranslator = TRANSLATORS.module_dict[translator]
+ if params is not None:
+ self.translator = translator_module(source, target, raise_unsupported_lang=False, **params)
+ else:
+ self.translator = translator_module(source, target, raise_unsupported_lang=False)
+ cfg_module.translate_source = self.translator.lang_source
+ cfg_module.translate_target = self.translator.lang_target
+ cfg_module.translator = self.translator.name
+ except Exception as e:
+ if old_translator is None:
+ old_translator = TRANSLATORS.module_dict['google']('简体中文', 'English', raise_unsupported_lang=False)
+ self.translator = old_translator
+ msg = self.tr('Failed to set translator ') + translator
+ create_error_dialog(e, msg, 'FailedSetTranslator')
+
+ self.module = self.translator
+ self.finish_set_module.emit()
+
+ def setTranslator(self, translator: str):
+ if translator in ['Sugoi']:
+ self._set_translator(translator)
+ else:
+ self.job = lambda : self._set_translator(translator)
+ self.start()
+
+ def _translate_page(self, page_dict, page_key: str, emit_finished=True):
+ page = page_dict[page_key]
+ try:
+ self.translator.translate_textblk_lst(page)
+ except Exception as e:
+ create_error_dialog(e, self.tr('Translation Failed.'), 'TranslationFailed')
+ if emit_finished:
+ self.finish_translate_page.emit(page_key)
+
+ def translatePage(self, page_dict, page_key: str):
+ self.job = lambda: self._translate_page(page_dict, page_key)
+ self.start()
+
+ def push_pagekey_queue(self, page_key: str):
+ self.pipeline_pagekey_queue.append(page_key)
+
+ def runTranslatePipeline(self, imgtrans_proj: ProjImgTrans):
+ self.initImgtransPipeline(imgtrans_proj)
+ self.job = self._run_translate_pipeline
+ self.start()
+
+ def _run_translate_pipeline(self):
+ delay = self.translator.delay()
+
+ while not self.pipeline_finished():
+ if len(self.pipeline_pagekey_queue) == 0:
+ time.sleep(0.1)
+ continue
+
+ page_key = self.pipeline_pagekey_queue.pop(0)
+ self.blockSignals(True)
+ try:
+ self._translate_page(self.imgtrans_proj.pages, page_key, emit_finished=False)
+ except Exception as e:
+
+ # TODO: allowing retry/skip/terminate
+
+ msg = self.tr('Translation Failed.')
+ if isinstance(e, MissingTranslatorParams):
+ msg = msg + '\n' + str(e) + self.tr(' is required for ' + self.translator.name)
+
+ self.blockSignals(False)
+ create_error_dialog(e, msg, 'TranslationFailed')
+ # self.imgtrans_proj = None
+ # self.finished_counter = 0
+ # self.pipeline_pagekey_queue = []
+ # return
+ self.blockSignals(False)
+ self.finished_counter += 1
+ self.progress_changed.emit(self.finished_counter)
+
+ if not self.pipeline_finished() and delay > 0:
+ time.sleep(delay)
+
+
+class ImgtransThread(QThread):
+
+ finished = Signal(object)
+ update_detect_progress = Signal(int)
+ update_ocr_progress = Signal(int)
+ update_translate_progress = Signal(int)
+ update_inpaint_progress = Signal(int)
+
+ finish_blktrans_stage = Signal(str, int)
+ finish_blktrans = Signal(int, list)
+ unload_modules = Signal(list)
+
+ detect_counter = 0
+ ocr_counter = 0
+ translate_counter = 0
+ inpaint_counter = 0
+
+ def __init__(self,
+ textdetect_thread: TextDetectThread,
+ ocr_thread: OCRThread,
+ translate_thread: TranslateThread,
+ inpaint_thread: InpaintThread,
+ *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+ self.textdetect_thread = textdetect_thread
+ self.ocr_thread = ocr_thread
+ self.translate_thread = translate_thread
+ self.inpaint_thread = inpaint_thread
+ self.job = None
+ self.imgtrans_proj: ProjImgTrans = None
+
+ @property
+ def textdetector(self) -> TextDetectorBase:
+ return self.textdetect_thread.textdetector
+
+ @property
+ def ocr(self) -> OCRBase:
+ return self.ocr_thread.ocr
+
+ @property
+ def translator(self) -> BaseTranslator:
+ return self.translate_thread.translator
+
+ @property
+ def inpainter(self) -> InpainterBase:
+ return self.inpaint_thread.inpainter
+
+ def runImgtransPipeline(self, imgtrans_proj: ProjImgTrans):
+ self.imgtrans_proj = imgtrans_proj
+ self.num_pages = len(self.imgtrans_proj.pages)
+ self.job = self._imgtrans_pipeline
+ self.start()
+
+ def runBlktransPipeline(self, blk_list: List[TextBlock], tgt_img: np.ndarray, mode: int, blk_ids: List[int], tgt_mask):
+ self.job = lambda : self._blktrans_pipeline(blk_list, tgt_img, mode, blk_ids, tgt_mask)
+ self.start()
+
+ def _blktrans_pipeline(self, blk_list: List[TextBlock], tgt_img: np.ndarray, mode: int, blk_ids: List[int], tgt_mask):
+ if mode >= 0 and mode < 3:
+ try:
+ self.ocr_thread.module.run_ocr(tgt_img, blk_list, split_textblk=True)
+ except Exception as e:
+ create_error_dialog(e, self.tr('OCR Failed.'), 'OCRFailed')
+ self.finish_blktrans.emit(mode, blk_ids)
+
+ if mode != 0 and mode < 3:
+ self.translate_thread.module.translate_textblk_lst(blk_list)
+ self.finish_blktrans.emit(mode, blk_ids)
+ if mode > 1:
+ im_h, im_w = tgt_img.shape[:2]
+ progress_prod = 100. / len(blk_list) if len(blk_list) > 0 else 0
+ for ii, blk in enumerate(blk_list):
+ xyxy = enlarge_window(blk.xyxy, im_w, im_h)
+ xyxy = np.array(xyxy)
+ x1, y1, x2, y2 = xyxy.astype(np.int64)
+ blk.region_inpaint_dict = None
+ if y2 - y1 > 2 and x2 - x1 > 2:
+ im = np.copy(tgt_img[y1: y2, x1: x2])
+ maskseg_method = get_maskseg_method()
+ inpaint_mask_array, ballon_mask, bub_dict = maskseg_method(im, mask=tgt_mask[y1: y2, x1: x2])
+ mask = self.post_process_mask(inpaint_mask_array)
+ if mask.sum() > 0:
+ inpainted = self.inpaint_thread.inpainter.inpaint(im, mask)
+ blk.region_inpaint_dict = {'img': im, 'mask': mask, 'inpaint_rect': [x1, y1, x2, y2], 'inpainted': inpainted}
+ self.finish_blktrans_stage.emit('inpaint', int((ii+1) * progress_prod))
+ self.finish_blktrans.emit(mode, blk_ids)
+
+ def _imgtrans_pipeline(self):
+ self.detect_counter = 0
+ self.ocr_counter = 0
+ self.translate_counter = 0
+ self.inpaint_counter = 0
+ self.num_pages = num_pages = len(self.imgtrans_proj.pages)
+
+ low_vram_trans = False
+ if self.translator is not None:
+ low_vram_trans = self.translator.low_vram_mode
+ self.parallel_trans = not self.translator.is_computational_intensive() and not low_vram_trans
+ else:
+ self.parallel_trans = False
+ if self.parallel_trans and cfg_module.enable_translate:
+ self.translate_thread.runTranslatePipeline(self.imgtrans_proj)
+
+ for imgname in self.imgtrans_proj.pages:
+ img = self.imgtrans_proj.read_img(imgname)
+ mask = blk_list = None
+ need_save_mask = False
+ blk_removed: List[TextBlock] = []
+ if cfg_module.enable_detect:
+ try:
+ mask, blk_list = self.textdetector.detect(img, self.imgtrans_proj)
+ need_save_mask = True
+ except Exception as e:
+ create_error_dialog(e, self.tr('Text Detection Failed.'), 'TextDetectFailed')
+ blk_list = []
+ self.detect_counter += 1
+ if pcfg.module.keep_exist_textlines:
+ blk_list = self.imgtrans_proj.pages[imgname] + blk_list
+ blk_list = sort_regions(blk_list)
+ existed_mask = self.imgtrans_proj.load_mask_by_imgname(imgname)
+ if existed_mask is not None:
+ mask = np.bitwise_or(mask, existed_mask)
+ self.imgtrans_proj.pages[imgname] = blk_list
+
+ if mask is not None and not cfg_module.enable_ocr:
+ self.imgtrans_proj.save_mask(imgname, mask)
+ need_save_mask = False
+
+ self.update_detect_progress.emit(self.detect_counter)
+
+ if blk_list is None:
+ blk_list = self.imgtrans_proj.pages[imgname] if imgname in self.imgtrans_proj.pages else []
+
+ if cfg_module.enable_ocr:
+ try:
+ self.ocr.run_ocr(img, blk_list)
+ except Exception as e:
+ create_error_dialog(e, self.tr('OCR Failed.'), 'OCRFailed')
+ self.ocr_counter += 1
+
+ if pcfg.restore_ocr_empty:
+ blk_list_updated = []
+ for blk in blk_list:
+ text = blk.get_text()
+ if text_is_empty(text):
+ blk_removed.append(blk)
+ else:
+ blk_list_updated.append(blk)
+
+ if len(blk_removed) > 0:
+ blk_list.clear()
+ blk_list += blk_list_updated
+
+ if mask is None:
+ mask = self.imgtrans_proj.load_mask_by_imgname(imgname)
+ if mask is not None:
+ inpainted = None
+ if not cfg_module.enable_inpaint:
+ inpainted = self.imgtrans_proj.load_inpainted_by_imgname(imgname)
+ for blk in blk_removed:
+ xywh = blk.bounding_rect()
+ blk_mask, xyxy = get_block_mask(xywh, mask, blk.angle)
+ x1, y1, x2, y2 = xyxy
+ if blk_mask is not None:
+ mask[y1: y2, x1: x2] = 0
+ if inpainted is not None:
+ mskpnt = np.where(blk_mask)
+ inpainted[y1: y2, x1: x2][mskpnt] = img[y1: y2, x1: x2][mskpnt]
+ need_save_mask = True
+ if inpainted is not None and need_save_mask:
+ self.imgtrans_proj.save_inpainted(imgname, inpainted)
+ if need_save_mask:
+ self.imgtrans_proj.save_mask(imgname, mask)
+ need_save_mask = False
+
+ self.update_ocr_progress.emit(self.ocr_counter)
+
+ if need_save_mask and mask is not None:
+ self.imgtrans_proj.save_mask(imgname, mask)
+ need_save_mask = False
+
+ if cfg_module.enable_translate:
+ if self.parallel_trans:
+ self.translate_thread.push_pagekey_queue(imgname)
+ elif not low_vram_trans:
+ self.translator.translate_textblk_lst(blk_list)
+ self.translate_counter += 1
+ self.update_translate_progress.emit(self.translate_counter)
+
+ if cfg_module.enable_inpaint:
+ if mask is None:
+ mask = self.imgtrans_proj.load_mask_by_imgname(imgname)
+
+ if mask is not None:
+ try:
+ inpainted = self.inpainter.inpaint(img, mask, blk_list)
+ self.imgtrans_proj.save_inpainted(imgname, inpainted)
+ except Exception as e:
+ create_error_dialog(e, self.tr('Inpainting Failed.'), 'InpaintFailed')
+
+ self.inpaint_counter += 1
+ self.update_inpaint_progress.emit(self.inpaint_counter)
+ else:
+ if len(blk_removed) > 0:
+ self.imgtrans_proj.load_mask_by_imgname
+
+ if cfg_module.enable_translate and low_vram_trans:
+ unload_modules(self, ['textdetector', 'inpainter', 'ocr'])
+ for imgname in self.imgtrans_proj.pages:
+ blk_list = self.imgtrans_proj.pages[imgname]
+ self.translator.translate_textblk_lst(blk_list)
+ self.translate_counter += 1
+ self.update_translate_progress.emit(self.translate_counter)
+
+ def detect_finished(self) -> bool:
+ if self.imgtrans_proj is None:
+ return True
+ return self.detect_counter == self.num_pages or not cfg_module.enable_detect
+
+ def ocr_finished(self) -> bool:
+ if self.imgtrans_proj is None:
+ return True
+ return self.ocr_counter == self.num_pages or not cfg_module.enable_ocr
+
+ def translate_finished(self) -> bool:
+ if self.imgtrans_proj is None \
+ or not cfg_module.enable_ocr \
+ or not cfg_module.enable_translate:
+ return True
+ if self.parallel_trans:
+ return self.translate_thread.pipeline_finished()
+ return self.translate_counter == self.num_pages or not cfg_module.enable_translate
+
+ def inpaint_finished(self) -> bool:
+ if self.imgtrans_proj is None or not cfg_module.enable_inpaint:
+ return True
+ return self.inpaint_counter == self.num_pages or not cfg_module.enable_inpaint
+
+ def run(self):
+ if self.job is not None:
+ self.job()
+ self.job = None
+
+ def recent_finished_index(self, ref_counter: int) -> int:
+ if cfg_module.enable_detect:
+ ref_counter = min(ref_counter, self.detect_counter)
+ if cfg_module.enable_ocr:
+ ref_counter = min(ref_counter, self.ocr_counter)
+ if cfg_module.enable_inpaint:
+ ref_counter = min(ref_counter, self.inpaint_counter)
+ if cfg_module.enable_translate:
+ if self.parallel_trans:
+ ref_counter = min(ref_counter, self.translate_thread.finished_counter)
+ else:
+ ref_counter = min(ref_counter, self.translate_counter)
+
+ return ref_counter - 1
+
+
+def unload_modules(self, module_names):
+ model_deleted = False
+ for module in module_names:
+ module: BaseModule = getattr(self, module)
+ model_deleted = model_deleted or module.unload_model()
+ if model_deleted:
+ soft_empty_cache()
+
+
+class ModuleManager(QObject):
+ imgtrans_proj: ProjImgTrans = None
+
+ finish_translate_page = Signal(str)
+ canvas_inpaint_finished = Signal(dict)
+ inpaint_th_finished = Signal()
+
+ imgtrans_pipeline_finished = Signal()
+ blktrans_pipeline_finished = Signal(int, list)
+ page_trans_finished = Signal(int)
+
+ run_canvas_inpaint = False
+ is_waiting_th = False
+ block_set_inpainter = False
+
+ def __init__(self,
+ imgtrans_proj: ProjImgTrans,
+ *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+ self.imgtrans_proj = imgtrans_proj
+ self.check_inpaint_fin_timer = QTimer(self)
+ self.check_inpaint_fin_timer.timeout.connect(self.check_inpaint_th_finished)
+
+ def setupThread(self, config_panel: ConfigPanel, imgtrans_progress_msgbox: ImgtransProgressMessageBox, ocr_postprocess: Callable = None, translate_preprocess: Callable = None, translate_postprocess: Callable = None):
+ self.textdetect_thread = TextDetectThread()
+
+ self.ocr_thread = OCRThread()
+
+ self.translate_thread = TranslateThread()
+ self.translate_thread.progress_changed.connect(self.on_update_translate_progress)
+ self.translate_thread.finish_translate_page.connect(self.on_finish_translate_page)
+
+ self.inpaint_thread = InpaintThread()
+ self.inpaint_thread.finish_inpaint.connect(self.on_finish_inpaint)
+
+ self.progress_msgbox = imgtrans_progress_msgbox
+
+ self.imgtrans_thread = ImgtransThread(self.textdetect_thread, self.ocr_thread, self.translate_thread, self.inpaint_thread)
+ self.imgtrans_thread.update_detect_progress.connect(self.on_update_detect_progress)
+ self.imgtrans_thread.update_ocr_progress.connect(self.on_update_ocr_progress)
+ self.imgtrans_thread.update_translate_progress.connect(self.on_update_translate_progress)
+ self.imgtrans_thread.update_inpaint_progress.connect(self.on_update_inpaint_progress)
+ self.imgtrans_thread.finish_blktrans_stage.connect(self.on_finish_blktrans_stage)
+ self.imgtrans_thread.finish_blktrans.connect(self.on_finish_blktrans)
+
+ self.translator_panel = translator_panel = config_panel.trans_config_panel
+ translator_params = merge_config_module_params(cfg_module.translator_params, GET_VALID_TRANSLATORS(), TRANSLATORS.get)
+ translator_panel.addModulesParamWidgets(translator_params)
+ translator_panel.translator_changed.connect(self.setTranslator)
+ translator_panel.paramwidget_edited.connect(self.on_translatorparam_edited)
+ from modules.translators.hooks import chs2cht
+ BaseTranslator.register_preprocess_hooks({'keyword_sub': translate_preprocess})
+ BaseTranslator.register_postprocess_hooks({'chs2cht': chs2cht, 'keyword_sub': translate_postprocess})
+
+ self.inpaint_panel = inpainter_panel = config_panel.inpaint_config_panel
+ inpainter_params = merge_config_module_params(cfg_module.inpainter_params, GET_VALID_INPAINTERS(), INPAINTERS.get)
+ inpainter_panel.addModulesParamWidgets(inpainter_params)
+ inpainter_panel.paramwidget_edited.connect(self.on_inpainterparam_edited)
+ inpainter_panel.inpainter_changed.connect(self.setInpainter)
+ inpainter_panel.needInpaintChecker.checker_changed.connect(self.on_inpainter_checker_changed)
+ inpainter_panel.needInpaintChecker.checker.setChecked(cfg_module.check_need_inpaint)
+
+ self.textdetect_panel = textdetector_panel = config_panel.detect_config_panel
+ textdetector_params = merge_config_module_params(cfg_module.textdetector_params, GET_VALID_TEXTDETECTORS(), TEXTDETECTORS.get)
+ textdetector_panel.addModulesParamWidgets(textdetector_params)
+ textdetector_panel.paramwidget_edited.connect(self.on_textdetectorparam_edited)
+ textdetector_panel.detector_changed.connect(self.setTextDetector)
+
+ self.ocr_panel = ocr_panel = config_panel.ocr_config_panel
+ ocr_params = merge_config_module_params(cfg_module.ocr_params, GET_VALID_OCR(), OCR.get)
+ ocr_panel.addModulesParamWidgets(ocr_params)
+ ocr_panel.paramwidget_edited.connect(self.on_ocrparam_edited)
+ ocr_panel.ocr_changed.connect(self.setOCR)
+ OCRBase.register_postprocess_hooks(ocr_postprocess)
+
+ config_panel.unload_models.connect(self.unload_all_models)
+
+
+ def unload_all_models(self):
+ unload_modules(self, {'textdetector', 'inpainter', 'ocr', 'translator'})
+
+ @property
+ def translator(self) -> BaseTranslator:
+ return self.translate_thread.translator
+
+ @property
+ def inpainter(self) -> InpainterBase:
+ return self.inpaint_thread.inpainter
+
+ @property
+ def textdetector(self) -> TextDetectorBase:
+ return self.textdetect_thread.textdetector
+
+ @property
+ def ocr(self) -> OCRBase:
+ return self.ocr_thread.ocr
+
+ def translatePage(self, run_target: bool, page_key: str):
+ if not run_target:
+ if self.translate_thread.isRunning():
+ LOGGER.warning('Terminating a running translation thread.')
+ self.translate_thread.terminate()
+ return
+ self.translate_thread.translatePage(self.imgtrans_proj.pages, page_key)
+
+ def inpainterBusy(self):
+ return self.inpaint_thread.isRunning()
+
+ def inpaint(self, img: np.ndarray, mask: np.ndarray, img_key: str = None, inpaint_rect = None, **kwargs):
+ if self.inpaint_thread.isRunning():
+ LOGGER.warning('Waiting for inpainting to finish')
+ return
+ self.inpaint_thread.inpaint(img, mask, img_key, inpaint_rect)
+
+ def terminateRunningThread(self):
+ if self.textdetect_thread.isRunning():
+ self.textdetect_thread.quit()
+ if self.ocr_thread.isRunning():
+ self.ocr_thread.quit()
+ if self.inpaint_thread.isRunning():
+ self.inpaint_thread.quit()
+ if self.translate_thread.isRunning():
+ self.translate_thread.quit()
+
+ def check_inpaint_th_finished(self):
+ if self.inpaint_thread.isRunning():
+ return
+ self.block_set_inpainter = False
+ self.check_inpaint_fin_timer.stop()
+ self.inpaint_th_finished.emit()
+
+ def runImgtransPipeline(self):
+ if self.imgtrans_proj.is_empty:
+ LOGGER.info('proj file is empty, nothing to do')
+ self.progress_msgbox.hide()
+ return
+ self.last_finished_index = -1
+ self.terminateRunningThread()
+
+ if cfg_module.all_stages_disabled() and self.imgtrans_proj is not None and self.imgtrans_proj.num_pages > 0:
+ for ii in range(self.imgtrans_proj.num_pages):
+ self.page_trans_finished.emit(ii)
+ self.imgtrans_pipeline_finished.emit()
+ return
+
+ self.progress_msgbox.detect_bar.setVisible(cfg_module.enable_detect)
+ self.progress_msgbox.ocr_bar.setVisible(cfg_module.enable_ocr)
+ self.progress_msgbox.translate_bar.setVisible(cfg_module.enable_translate)
+ self.progress_msgbox.inpaint_bar.setVisible(cfg_module.enable_inpaint)
+ self.progress_msgbox.zero_progress()
+ self.progress_msgbox.show()
+ self.imgtrans_thread.runImgtransPipeline(self.imgtrans_proj)
+
+ def runBlktransPipeline(self, blk_list: List[TextBlock], tgt_img: np.ndarray, mode: int, blk_ids: List[int], tgt_mask):
+ self.terminateRunningThread()
+ self.progress_msgbox.hide_all_bars()
+ if mode >= 0 and mode < 3:
+ self.progress_msgbox.ocr_bar.show()
+ if mode >= 2:
+ self.progress_msgbox.inpaint_bar.show()
+ if mode != 0 and mode < 3:
+ self.progress_msgbox.translate_bar.show()
+ self.progress_msgbox.zero_progress()
+ self.progress_msgbox.show()
+ self.imgtrans_thread.runBlktransPipeline(blk_list, tgt_img, mode, blk_ids, tgt_mask)
+
+ def on_finish_blktrans_stage(self, stage: str, progress: int):
+ if stage == 'ocr':
+ self.progress_msgbox.updateOCRProgress(progress)
+ elif stage == 'translate':
+ self.progress_msgbox.updateTranslateProgress(progress)
+ elif stage == 'inpaint':
+ self.progress_msgbox.updateInpaintProgress(progress)
+ else:
+ raise NotImplementedError(f'Unknown stage: {stage}')
+
+ def on_finish_blktrans(self, mode: int, blk_ids: List):
+ self.blktrans_pipeline_finished.emit(mode, blk_ids)
+ self.progress_msgbox.hide()
+
+ def on_update_detect_progress(self, progress: int):
+ ri = self.imgtrans_thread.recent_finished_index(progress)
+ if 'detect' in shared.pbar:
+ shared.pbar['detect'].update(1)
+ progress = int(progress / self.imgtrans_thread.num_pages * 100)
+ self.progress_msgbox.updateDetectProgress(progress)
+ if ri != self.last_finished_index:
+ self.last_finished_index = ri
+ self.page_trans_finished.emit(ri)
+ if progress == 100:
+ self.finishImgtransPipeline()
+
+ def on_update_ocr_progress(self, progress: int):
+ ri = self.imgtrans_thread.recent_finished_index(progress)
+ if 'ocr' in shared.pbar:
+ shared.pbar['ocr'].update(1)
+ progress = int(progress / self.imgtrans_thread.num_pages * 100)
+ self.progress_msgbox.updateOCRProgress(progress)
+ if ri != self.last_finished_index:
+ self.last_finished_index = ri
+ self.page_trans_finished.emit(ri)
+ if progress == 100:
+ self.finishImgtransPipeline()
+
+ def on_update_translate_progress(self, progress: int):
+ ri = self.imgtrans_thread.recent_finished_index(progress)
+ if 'translate' in shared.pbar:
+ shared.pbar['translate'].update(1)
+ progress = int(progress / self.imgtrans_thread.num_pages * 100)
+ self.progress_msgbox.updateTranslateProgress(progress)
+ if ri != self.last_finished_index:
+ self.last_finished_index = ri
+ self.page_trans_finished.emit(ri)
+ if progress == 100:
+ self.finishImgtransPipeline()
+
+ def on_update_inpaint_progress(self, progress: int):
+ ri = self.imgtrans_thread.recent_finished_index(progress)
+ if 'inpaint' in shared.pbar:
+ shared.pbar['inpaint'].update(1)
+ progress = int(progress / self.imgtrans_thread.num_pages * 100)
+ self.progress_msgbox.updateInpaintProgress(progress)
+ if ri != self.last_finished_index:
+ self.last_finished_index = ri
+ self.page_trans_finished.emit(ri)
+ if progress == 100:
+ self.finishImgtransPipeline()
+
+ def progress(self):
+ progress = {}
+ num_pages = self.imgtrans_thread.num_pages
+ if cfg_module.enable_detect:
+ progress['detect'] = self.imgtrans_thread.detect_counter / num_pages
+ if cfg_module.enable_ocr:
+ progress['ocr'] = self.imgtrans_thread.ocr_counter / num_pages
+ if cfg_module.enable_inpaint:
+ progress['inpaint'] = self.imgtrans_thread.inpaint_counter / num_pages
+ if cfg_module.enable_translate:
+ progress['translate'] = self.imgtrans_thread.translate_counter / num_pages
+ return progress
+
+ def proj_finished(self):
+ if self.imgtrans_thread.detect_finished() \
+ and self.imgtrans_thread.ocr_finished() \
+ and self.imgtrans_thread.translate_finished() \
+ and self.imgtrans_thread.inpaint_finished():
+ return True
+ return False
+
+ def finishImgtransPipeline(self):
+ if self.proj_finished():
+ self.progress_msgbox.hide()
+ self.imgtrans_pipeline_finished.emit()
+
+ def setTranslator(self, translator: str = None):
+ if translator is None:
+ translator = cfg_module.translator
+ if self.translate_thread.isRunning():
+ LOGGER.warning('Terminating a running translation thread.')
+ self.translate_thread.terminate()
+ self.translate_thread.setTranslator(translator)
+
+ def setInpainter(self, inpainter: str = None):
+
+ if self.block_set_inpainter:
+ return
+
+ if inpainter is None:
+ inpainter =cfg_module.inpainter
+
+ if self.inpaint_thread.isRunning():
+ self.block_set_inpainter = True
+ create_info_dialog(self.tr('Set Inpainter...'), modal=True, signal_slot_map_list=[{'signal': self.inpaint_th_finished, 'slot': 'done'}])
+ self.check_inpaint_fin_timer.start(300)
+ return
+
+ self.inpaint_thread.setInpainter(inpainter)
+
+ def setTextDetector(self, textdetector: str = None):
+ if textdetector is None:
+ textdetector = cfg_module.textdetector
+ if self.textdetect_thread.isRunning():
+ LOGGER.warning('Terminating a running text detection thread.')
+ self.textdetect_thread.terminate()
+ self.textdetect_thread.setTextDetector(textdetector)
+
+ def setOCR(self, ocr: str = None):
+ if ocr is None:
+ ocr = cfg_module.ocr
+ if self.ocr_thread.isRunning():
+ LOGGER.warning('Terminating a running OCR thread.')
+ self.ocr_thread.terminate()
+ self.ocr_thread.setOCR(ocr)
+
+ def on_finish_translate_page(self, page_key: str):
+ self.finish_translate_page.emit(page_key)
+
+ def on_finish_inpaint(self, inpaint_dict: dict):
+ if self.run_canvas_inpaint:
+ self.canvas_inpaint_finished.emit(inpaint_dict)
+ self.run_canvas_inpaint = False
+
+ def canvas_inpaint(self, inpaint_dict):
+ self.run_canvas_inpaint = True
+ self.inpaint(**inpaint_dict)
+
+ def on_translatorparam_edited(self, param_key: str, param_content: dict):
+ if self.translator is not None:
+ self.updateModuleSetupParam(self.translator, param_key, param_content)
+ cfg_module.translator_params[self.translator.name] = self.translator.params
+
+ def on_inpainterparam_edited(self, param_key: str, param_content: dict):
+ if self.inpainter is not None:
+ self.updateModuleSetupParam(self.inpainter, param_key, param_content)
+ cfg_module.inpainter_params[self.inpainter.name] = self.inpainter.params
+
+ def on_textdetectorparam_edited(self, param_key: str, param_content: dict):
+ if self.textdetector is not None:
+ self.updateModuleSetupParam(self.textdetector, param_key, param_content)
+ cfg_module.textdetector_params[self.textdetector.name] = self.textdetector.params
+
+ def on_ocrparam_edited(self, param_key: str, param_content: dict):
+ if self.ocr is not None:
+ self.updateModuleSetupParam(self.ocr, param_key, param_content)
+ cfg_module.ocr_params[self.ocr.name] = self.ocr.params
+
+ def updateModuleSetupParam(self,
+ module: Union[InpainterBase, BaseTranslator],
+ param_key: str, param_content: dict):
+
+ if param_content.get('flush', False):
+ param_widget: ParamComboBox = param_content['widget']
+ param_widget.blockSignals(True)
+ current_item = param_widget.currentText()
+ param_widget.clear()
+ param_widget.addItems(module.flush(param_key))
+ param_widget.setCurrentText(current_item)
+ param_widget.blockSignals(False)
+ elif param_content.get('select_path', False):
+ dialog = QFileDialog()
+ f = module.params[param_key].get('path_filter', None)
+ p = dialog.getOpenFileUrl(self.parent(), filter=f)[0].toLocalFile()
+ if osp.exists(p):
+ param_widget: ParamComboBox = param_content['widget']
+ param_widget.setCurrentText(p)
+ else:
+ module.updateParam(param_key, param_content['content'])
+
+ def handle_page_changed(self):
+ if not self.imgtrans_thread.isRunning():
+ if self.inpaint_thread.inpainting:
+ self.run_canvas_inpaint = False
+ self.inpaint_thread.terminate()
+
+ def on_inpainter_checker_changed(self, is_checked: bool):
+ cfg_module.check_need_inpaint = is_checked
+ InpainterBase.check_need_inpaint = is_checked
\ No newline at end of file
diff --git a/ui/module_parse_widgets.py b/ui/module_parse_widgets.py
new file mode 100644
index 0000000000000000000000000000000000000000..f30c2d637400a37afc097f42e0f4753b29d116df
--- /dev/null
+++ b/ui/module_parse_widgets.py
@@ -0,0 +1,457 @@
+from typing import List, Callable
+
+from modules import GET_VALID_INPAINTERS, GET_VALID_TEXTDETECTORS, GET_VALID_TRANSLATORS, GET_VALID_OCR, \
+ BaseTranslator, DEFAULT_DEVICE, GPUINTENSIVE_SET
+from utils.logger import logger as LOGGER
+from .custom_widget import ConfigComboBox, ParamComboBox, NoBorderPushBtn, ParamNameLabel
+from utils.shared import CONFIG_COMBOBOX_LONG, size2width, CONFIG_COMBOBOX_SHORT, CONFIG_COMBOBOX_HEIGHT
+from utils.config import pcfg
+
+from qtpy.QtWidgets import QPlainTextEdit, QHBoxLayout, QVBoxLayout, QWidget, QLabel, QCheckBox, QLineEdit, QGridLayout, QPushButton
+from qtpy.QtCore import Qt, Signal
+from qtpy.QtGui import QDoubleValidator
+
+
+class ParamCheckGroup(QWidget):
+
+ paramwidget_edited = Signal(str, dict)
+
+ def __init__(self, param_key, check_group: dict, parent=None) -> None:
+ super().__init__(parent=parent)
+ self.param_key = param_key
+ layout = QHBoxLayout(self)
+ self.label2widget = {}
+ for k, v in check_group.items():
+ checker = QCheckBox(text=k, parent=self)
+ checker.setChecked(v)
+ layout.addWidget(checker)
+ self.label2widget[k] = checker
+ checker.clicked.connect(self.on_checker_clicked)
+
+ def on_checker_clicked(self):
+ new_state_dict = {}
+ w = QCheckBox()
+ for k, w in self.label2widget.items():
+ new_state_dict[k] = w.isChecked()
+ self.paramwidget_edited.emit(self.param_key, new_state_dict)
+
+
+class ParamLineEditor(QLineEdit):
+
+ paramwidget_edited = Signal(str, str)
+ def __init__(self, param_key: str, force_digital, size='short', *args, **kwargs) -> None:
+ super().__init__( *args, **kwargs)
+ self.param_key = param_key
+ self.setFixedWidth(size2width(size))
+ self.setFixedHeight(CONFIG_COMBOBOX_HEIGHT)
+ self.textChanged.connect(self.on_text_changed)
+
+ if force_digital:
+ validator = QDoubleValidator()
+ self.setValidator(validator)
+
+ def on_text_changed(self):
+ self.paramwidget_edited.emit(self.param_key, self.text())
+
+class ParamEditor(QPlainTextEdit):
+
+ paramwidget_edited = Signal(str, str)
+ def __init__(self, param_key: str, *args, **kwargs) -> None:
+ super().__init__( *args, **kwargs)
+ self.param_key = param_key
+
+ if param_key == 'chat sample':
+ self.setFixedWidth(int(CONFIG_COMBOBOX_LONG * 1.2))
+ self.setFixedHeight(200)
+ else:
+ self.setFixedWidth(CONFIG_COMBOBOX_LONG)
+ self.setFixedHeight(100)
+ # self.setFixedHeight(CONFIG_COMBOBOX_HEIGHT)
+ self.textChanged.connect(self.on_text_changed)
+
+ def on_text_changed(self):
+ self.paramwidget_edited.emit(self.param_key, self.text())
+
+ def setText(self, text: str):
+ self.setPlainText(text)
+
+ def text(self):
+ return self.toPlainText()
+
+
+class ParamCheckerBox(QWidget):
+ checker_changed = Signal(bool)
+ paramwidget_edited = Signal(str, str)
+ def __init__(self, param_key: str, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.param_key = param_key
+ self.checker = QCheckBox()
+ name_label = ParamNameLabel(param_key)
+ hlayout = QHBoxLayout(self)
+ hlayout.addWidget(name_label)
+ hlayout.addWidget(self.checker)
+ hlayout.setAlignment(Qt.AlignmentFlag.AlignLeft)
+ self.checker.stateChanged.connect(self.on_checker_changed)
+
+ def on_checker_changed(self):
+ is_checked = self.checker.isChecked()
+ self.checker_changed.emit(is_checked)
+ checked = 'true' if is_checked else 'false'
+ self.paramwidget_edited.emit(self.param_key, checked)
+
+
+class ParamCheckBox(QCheckBox):
+ paramwidget_edited = Signal(str, bool)
+ def __init__(self, param_key: str, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.param_key = param_key
+ self.stateChanged.connect(self.on_checker_changed)
+
+ def on_checker_changed(self):
+ self.paramwidget_edited.emit(self.param_key, self.isChecked())
+
+
+def get_param_display_name(param_key: str, param_dict: dict = None):
+ if param_dict is not None and isinstance(param_dict, dict):
+ if 'display_name' in param_dict:
+ return param_dict['display_name']
+ return param_key
+
+
+class ParamPushButton(QPushButton):
+ paramwidget_edited = Signal(str, str)
+ def __init__(self, param_key: str, param_dict: dict = None, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.param_key = param_key
+ self.setText(get_param_display_name(param_key, param_dict))
+ self.clicked.connect(self.on_clicked)
+
+ def on_clicked(self):
+ self.paramwidget_edited.emit(self.param_key, '')
+
+
+class ParamWidget(QWidget):
+
+ paramwidget_edited = Signal(str, dict)
+ def __init__(self, params, scrollWidget: QWidget = None, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+ layout = QHBoxLayout(self)
+ self.param_layout = param_layout = QGridLayout()
+ param_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
+ param_layout.setContentsMargins(0, 0, 0, 0)
+ param_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
+ layout.addLayout(param_layout)
+ layout.addStretch(-1)
+
+ if 'description' in params:
+ self.setToolTip(params['description'])
+
+ for ii, param_key in enumerate(params):
+ if param_key == 'description' or param_key.startswith('__'):
+ continue
+ display_param_name = param_key
+
+ require_label = True
+ is_str = isinstance(params[param_key], str)
+ is_digital = isinstance(params[param_key], float) or isinstance(params[param_key], int)
+ param_widget = None
+
+ if isinstance(params[param_key], bool):
+ param_widget = ParamCheckBox(param_key)
+ val = params[param_key]
+ param_widget.setChecked(val)
+ param_widget.paramwidget_edited.connect(self.on_paramwidget_edited)
+
+ elif is_str or is_digital:
+ param_widget = ParamLineEditor(param_key, force_digital=is_digital)
+ val = params[param_key]
+ if is_digital:
+ val = str(val)
+ param_widget.setText(val)
+ param_widget.paramwidget_edited.connect(self.on_paramwidget_edited)
+
+ elif isinstance(params[param_key], dict):
+ param_dict = params[param_key]
+ display_param_name = get_param_display_name(param_key, param_dict)
+ value = params[param_key]['value']
+ param_widget = None # Ensure initialization
+ param_type = param_dict['type'] if 'type' in param_dict else 'line_editor'
+ flush_btn = param_dict.get('flush_btn', False)
+ path_selector = param_dict.get('path_selector', False)
+ param_size = param_dict.get('size', 'short')
+ if param_type == 'selector':
+ if 'url' in param_key:
+ size = size2width('median')
+ else:
+ size = size2width(param_size)
+
+ param_widget = ParamComboBox(
+ param_key, param_dict['options'], size=size, scrollWidget=scrollWidget, flush_btn=flush_btn, path_selector=path_selector)
+
+ if param_key == 'device' and DEFAULT_DEVICE == 'cpu':
+ param_dict['value'] = 'cpu'
+ for ii, device in enumerate(param_dict['options']):
+ if device in GPUINTENSIVE_SET:
+ model = param_widget.model()
+ item = model.item(ii, 0)
+ item.setEnabled(False)
+ param_widget.setCurrentText(str(value))
+ param_widget.setEditable(param_dict.get('editable', False))
+
+ elif param_type == 'editor':
+ param_widget = ParamEditor(param_key)
+ param_widget.setText(value)
+
+ elif param_type == 'checkbox':
+ param_widget = ParamCheckBox(param_key)
+ if isinstance(value, str):
+ value = value.lower().strip() == 'true'
+ params[param_key]['value'] = value
+ param_widget.setChecked(value)
+
+ elif param_type == 'pushbtn':
+ param_widget = ParamPushButton(param_key, param_dict)
+ require_label = False
+
+ elif param_type == 'line_editor':
+ param_widget = ParamLineEditor(param_key, force_digital=is_digital)
+ param_widget.setText(str(value))
+
+ elif param_type == 'check_group':
+ param_widget = ParamCheckGroup(param_key, check_group=value)
+
+ if param_widget is not None:
+ param_widget.paramwidget_edited.connect(self.on_paramwidget_edited)
+ if 'description' in param_dict:
+ param_widget.setToolTip(param_dict['description'])
+
+ widget_idx = 0
+ if require_label:
+ param_label = ParamNameLabel(display_param_name)
+ param_layout.addWidget(param_label, ii, 0)
+ widget_idx = 1
+ if param_widget is not None:
+ pw_lo = None
+ if hasattr(param_widget, 'flush_btn') or hasattr(param_widget, 'path_select_btn'):
+ pw_lo = QHBoxLayout()
+ pw_lo.addWidget(param_widget)
+ if hasattr(param_widget, 'flush_btn'):
+ pw_lo.addWidget(param_widget.flush_btn)
+ param_widget.flushbtn_clicked.connect(self.on_flushbtn_clicked)
+ if hasattr(param_widget, 'path_select_btn'):
+ pw_lo.addWidget(param_widget.path_select_btn)
+ param_widget.pathbtn_clicked.connect(self.on_pathbtn_clicked)
+ if pw_lo is None:
+ param_layout.addWidget(param_widget, ii, widget_idx)
+ else:
+ param_layout.addLayout(pw_lo, ii, widget_idx)
+ else:
+ v = params[param_key]
+ raise ValueError(f"Failed to initialize widget for key-value pair: {param_key}-{v}")
+
+ def on_flushbtn_clicked(self):
+ paramw: ParamComboBox = self.sender()
+ content_dict = {'content': '', 'widget': paramw, 'flush': True}
+ self.paramwidget_edited.emit(paramw.param_key, content_dict)
+
+ def on_pathbtn_clicked(self):
+ paramw: ParamComboBox = self.sender()
+ content_dict = {'content': '', 'widget': paramw, 'select_path': True}
+ self.paramwidget_edited.emit(paramw.param_key, content_dict)
+
+ def on_paramwidget_edited(self, param_key, param_content):
+ content_dict = {'content': param_content}
+ self.paramwidget_edited.emit(param_key, content_dict)
+
+class ModuleParseWidgets(QWidget):
+ def addModulesParamWidgets(self, ocr_instance):
+ self.params = ocr_instance.get_params()
+ self.on_module_changed()
+
+ def on_module_changed(self):
+ self.updateModuleParamWidget()
+
+ def updateModuleParamWidget(self):
+ widget = ParamWidget(self.params, scrollWidget=self)
+ layout = QVBoxLayout()
+ layout.addWidget(widget)
+ self.setLayout(layout)
+
+class ModuleConfigParseWidget(QWidget):
+ module_changed = Signal(str)
+ paramwidget_edited = Signal(str, dict)
+ def __init__(self, module_name: str, get_valid_module_keys: Callable, scrollWidget: QWidget, add_from: int = 1, *args, **kwargs) -> None:
+ super().__init__( *args, **kwargs)
+ self.get_valid_module_keys = get_valid_module_keys
+ self.module_combobox = ConfigComboBox(scrollWidget=scrollWidget)
+ self.params_layout = QHBoxLayout()
+ self.params_layout.setContentsMargins(0, 0, 0, 0)
+
+ p_layout = QHBoxLayout()
+ p_layout.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
+ self.module_label = ParamNameLabel(module_name)
+ p_layout.addWidget(self.module_label)
+ p_layout.addWidget(self.module_combobox)
+ p_layout.addStretch(-1)
+ self.p_layout = p_layout
+
+ layout = QVBoxLayout(self)
+ self.param_widget_map = {}
+ layout.addLayout(p_layout)
+ layout.addLayout(self.params_layout)
+ layout.setSpacing(30)
+ self.vlayout = layout
+
+ self.visibleWidget: QWidget = None
+ self.module_dict: dict = {}
+
+ def addModulesParamWidgets(self, module_dict: dict):
+ invalid_module_keys = []
+ valid_modulekeys = self.get_valid_module_keys()
+
+ num_widgets_before = len(self.param_widget_map)
+
+ for module in module_dict:
+ if module not in valid_modulekeys:
+ invalid_module_keys.append(module)
+ continue
+
+ if module in self.param_widget_map:
+ LOGGER.warning(f'duplicated module key: {module}')
+ continue
+
+ self.module_combobox.addItem(module)
+ params = module_dict[module]
+ if params is not None:
+ self.param_widget_map[module] = None
+
+ if len(invalid_module_keys) > 0:
+ LOGGER.warning(F'Invalid module keys: {invalid_module_keys}')
+ for ik in invalid_module_keys:
+ module_dict.pop(ik)
+
+ self.module_dict = module_dict
+
+ num_widgets_after = len(self.param_widget_map)
+ if num_widgets_before == 0 and num_widgets_after > 0:
+ self.on_module_changed()
+ self.module_combobox.currentTextChanged.connect(self.on_module_changed)
+
+ def setModule(self, module: str):
+ self.blockSignals(True)
+ self.module_combobox.setCurrentText(module)
+ self.updateModuleParamWidget()
+ self.blockSignals(False)
+
+ def updateModuleParamWidget(self):
+ module = self.module_combobox.currentText()
+ if self.visibleWidget is not None:
+ self.visibleWidget.hide()
+ if module in self.param_widget_map:
+ widget: QWidget = self.param_widget_map[module]
+ if widget is None:
+ # lazy load widgets
+ params = self.module_dict[module]
+ widget = ParamWidget(params, scrollWidget=self)
+ widget.paramwidget_edited.connect(self.paramwidget_edited)
+ self.param_widget_map[module] = widget
+ self.params_layout.addWidget(widget)
+ else:
+ widget.show()
+ self.visibleWidget = widget
+
+ def on_module_changed(self):
+ self.updateModuleParamWidget()
+ self.module_changed.emit(self.module_combobox.currentText())
+
+
+class TranslatorConfigPanel(ModuleConfigParseWidget):
+
+ show_pre_MT_keyword_window = Signal()
+ show_MT_keyword_window = Signal()
+ show_OCR_keyword_window = Signal()
+
+ def __init__(self, module_name, scrollWidget: QWidget = None, *args, **kwargs) -> None:
+ super().__init__(module_name, GET_VALID_TRANSLATORS, scrollWidget=scrollWidget, *args, **kwargs)
+ self.translator_changed = self.module_changed
+
+ self.source_combobox = ConfigComboBox(scrollWidget=scrollWidget)
+ self.target_combobox = ConfigComboBox(scrollWidget=scrollWidget)
+ self.replacePreMTkeywordBtn = NoBorderPushBtn(self.tr("Keyword substitution for machine translation source text"), self)
+ self.replacePreMTkeywordBtn.clicked.connect(self.show_pre_MT_keyword_window)
+ self.replacePreMTkeywordBtn.setFixedWidth(500)
+ self.replaceMTkeywordBtn = NoBorderPushBtn(self.tr("Keyword substitution for machine translation"), self)
+ self.replaceMTkeywordBtn.clicked.connect(self.show_MT_keyword_window)
+ self.replaceMTkeywordBtn.setFixedWidth(500)
+ self.replaceOCRkeywordBtn = NoBorderPushBtn(self.tr("Keyword substitution for source text"), self)
+ self.replaceOCRkeywordBtn.clicked.connect(self.show_OCR_keyword_window)
+ self.replaceOCRkeywordBtn.setFixedWidth(500)
+
+ st_layout = QHBoxLayout()
+ st_layout.setSpacing(15)
+ st_layout.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
+ st_layout.addWidget(ParamNameLabel(self.tr('Source')))
+ st_layout.addWidget(self.source_combobox)
+ st_layout.addWidget(ParamNameLabel(self.tr('Target')))
+ st_layout.addWidget(self.target_combobox)
+
+ self.vlayout.insertLayout(1, st_layout)
+ self.vlayout.addWidget(self.replaceOCRkeywordBtn)
+ self.vlayout.addWidget(self.replacePreMTkeywordBtn)
+ self.vlayout.addWidget(self.replaceMTkeywordBtn)
+
+ def finishSetTranslator(self, translator: BaseTranslator):
+ self.source_combobox.blockSignals(True)
+ self.target_combobox.blockSignals(True)
+ self.module_combobox.blockSignals(True)
+
+ self.source_combobox.clear()
+ self.target_combobox.clear()
+
+ self.source_combobox.addItems(translator.supported_src_list)
+ self.target_combobox.addItems(translator.supported_tgt_list)
+ self.module_combobox.setCurrentText(translator.name)
+ self.source_combobox.setCurrentText(translator.lang_source)
+ self.target_combobox.setCurrentText(translator.lang_target)
+ self.updateModuleParamWidget()
+ self.source_combobox.blockSignals(False)
+ self.target_combobox.blockSignals(False)
+ self.module_combobox.blockSignals(False)
+
+
+class InpaintConfigPanel(ModuleConfigParseWidget):
+ def __init__(self, module_name: str, scrollWidget: QWidget = None, *args, **kwargs) -> None:
+ super().__init__(module_name, GET_VALID_INPAINTERS, scrollWidget = scrollWidget, *args, **kwargs)
+ self.inpainter_changed = self.module_changed
+ self.setInpainter = self.setModule
+ self.needInpaintChecker = ParamCheckerBox(self.tr('Let the program decide whether it is necessary to use the selected inpaint method.'))
+ self.vlayout.addWidget(self.needInpaintChecker)
+
+ def showEvent(self, e) -> None:
+ self.p_layout.insertWidget(1, self.module_combobox)
+ super().showEvent(e)
+
+ def hideEvent(self, e) -> None:
+ self.p_layout.removeWidget(self.module_combobox)
+ return super().hideEvent(e)
+
+class TextDetectConfigPanel(ModuleConfigParseWidget):
+ def __init__(self, module_name: str, scrollWidget: QWidget = None, *args, **kwargs) -> None:
+ super().__init__(module_name, GET_VALID_TEXTDETECTORS, scrollWidget = scrollWidget, *args, **kwargs)
+ self.detector_changed = self.module_changed
+ self.setDetector = self.setModule
+ self.keep_existing_checker = QCheckBox(text=self.tr('Keep Existing Lines'))
+ self.p_layout.insertWidget(2, self.keep_existing_checker)
+
+
+class OCRConfigPanel(ModuleConfigParseWidget):
+ def __init__(self, module_name: str, scrollWidget: QWidget = None, *args, **kwargs) -> None:
+ super().__init__(module_name, GET_VALID_OCR, scrollWidget = scrollWidget, *args, **kwargs)
+ self.ocr_changed = self.module_changed
+ self.setOCR = self.setModule
+ self.restoreEmptyOCRChecker = QCheckBox(self.tr("Delete and restore region where OCR return empty string."), self)
+ self.restoreEmptyOCRChecker.clicked.connect(self.on_restore_empty_ocr)
+ self.vlayout.addWidget(self.restoreEmptyOCRChecker)
+
+ def on_restore_empty_ocr(self):
+ pcfg.restore_ocr_empty = self.restoreEmptyOCRChecker.isChecked()
\ No newline at end of file
diff --git a/ui/page_search_widget.py b/ui/page_search_widget.py
new file mode 100644
index 0000000000000000000000000000000000000000..d4b8ae9d48640e37ec72a27ff63372dd1c3d6b94
--- /dev/null
+++ b/ui/page_search_widget.py
@@ -0,0 +1,735 @@
+from qtpy.QtWidgets import QHBoxLayout, QComboBox, QTextEdit, QLabel, QPlainTextEdit, QCheckBox, QVBoxLayout, QGraphicsDropShadowEffect, QWidget
+from qtpy.QtCore import Qt, QTimer, Signal
+from qtpy.QtGui import QKeyEvent, QTextCursor, QHideEvent, QInputMethodEvent, QFontMetrics, QColor, QShowEvent, QSyntaxHighlighter, QTextCharFormat
+
+from typing import List, Union, Tuple, Dict
+import re
+
+from utils.config import pcfg
+from .custom_widget import Widget, ClickableLabel
+from .textitem import TextBlkItem
+from .textedit_area import TransPairWidget, SourceTextEdit, TransTextEdit
+
+SEARCHRST_HIGHLIGHT_COLOR = QColor(30, 147, 229, 60)
+CURRENT_TEXT_COLOR = QColor(244, 249, 28)
+
+
+class Matched:
+ def __init__(self, local_no: int, start: int, end: int) -> None:
+ self.local_no = local_no
+ self.start = start
+ self.end = end
+
+
+def match_text(pattern: re.Pattern, text: str) -> Tuple[int, Dict]:
+ found_counter = 0
+ match_map = {}
+ rst_iter = pattern.finditer(text)
+ for rst in rst_iter:
+ span = rst.span()
+ match_map[span[1]] = Matched(found_counter, span[0], span[1])
+ found_counter += 1
+ return found_counter, match_map
+
+
+class HighlightMatched(QSyntaxHighlighter):
+
+ def __init__(self, edit: SourceTextEdit, matched_map: dict = None):
+ super().__init__(edit.document())
+
+ self.case_sensitive = False
+ self.whole_word = False
+ if matched_map is None:
+ self.matched_map: Dict = {}
+ else:
+ self.matched_map = matched_map
+ self.current_start = -1
+ self.edit = edit
+
+ def setEditor(self, edit: SourceTextEdit):
+ old_edit = self.edit
+ if old_edit is not None:
+ old_edit.highlighting = True
+ old_edit.block_all_signals(True)
+ if edit is not None:
+ edit.highlighting = True
+ self.setDocument(edit.document())
+ edit.highlighting = False
+ else:
+ self.setDocument(None)
+ self.edit = edit
+ if old_edit is not None:
+ old_edit.highlighting = False
+ old_edit.block_all_signals(False)
+
+ def set_matched_map(self, matched_map: dict):
+ self.matched_map = matched_map
+ self.rehighlight()
+
+ def rehighlight(self) -> None:
+ if self.edit is not None:
+ self.edit.highlighting = True
+ super().rehighlight()
+ if self.edit is not None:
+ self.edit.highlighting = False
+
+ def set_current_span(self, start: int, end: int):
+ self.current_start = start
+ self.current_end = end
+ self.rehighlight()
+
+ def highlightBlock(self, text: str) -> None:
+ if self.edit is None:
+ return
+ self.edit.highlighting = True
+ fmt = QTextCharFormat()
+ fmt.setBackground(SEARCHRST_HIGHLIGHT_COLOR)
+ block = self.currentBlock()
+ block_start = block.position()
+ block_end = block_start + block.length()
+ matched: Matched
+ for match_end, matched in self.matched_map.items():
+ match_start = matched.start
+ intersect_start = max(match_start, block_start)
+ intersect_end = min(match_end, block_end)
+ length = intersect_end - intersect_start
+ if length > 0:
+ self.setFormat(intersect_start - block_start, length, fmt)
+
+ if self.current_start >= 0:
+ intersect_start = max(self.current_start, block_start)
+ intersect_end = min(self.current_end, block_end)
+ length = intersect_end - intersect_start
+ if length > 0:
+ fmt.setBackground(CURRENT_TEXT_COLOR)
+ self.setFormat(intersect_start - block_start, length, fmt)
+ self.edit.highlighting = False
+
+
+class SearchEditor(QPlainTextEdit):
+ height_changed = Signal()
+ commit = Signal()
+ enter_pressed = Signal()
+ shift_enter_pressed = Signal()
+ def __init__(self, parent: QWidget = None, original_height: int = 32, commit_latency: int = -1, shift_enter_prev: bool = True, *args, **kwargs):
+ super().__init__(parent, *args, **kwargs)
+ self.original_height = original_height
+ self.commit_latency = commit_latency
+ self.shift_enter_prev = shift_enter_prev
+ if commit_latency > 0:
+ self.commit_timer = QTimer(self)
+ self.commit_timer.timeout.connect(self.on_commit_timer_timeout)
+ else:
+ self.commit_timer = None
+ self.pre_editing = False
+ self.setFixedHeight(original_height)
+ self.document().documentLayout().documentSizeChanged.connect(self.adjustSize)
+ self.textChanged.connect(self.on_text_changed)
+ self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+ self.setAttribute(Qt.WidgetAttribute.WA_InputMethodEnabled, True)
+
+ def adjustSize(self):
+ fm = QFontMetrics(self.font())
+ h = fm.height() * self.document().size().height() * 1.05
+ h += self.document().documentMargin() * 2
+ h = int(h)
+ if self.geometry().height() != h:
+ self.setFixedHeight(max(h, self.original_height))
+ self.height_changed.emit()
+
+ def keyPressEvent(self, e: QKeyEvent) -> None:
+ if e.key() == Qt.Key.Key_Return:
+ if self.commit_timer is not None:
+ self.commit_timer.stop()
+ if e.modifiers() == Qt.KeyboardModifier.ShiftModifier:
+ if self.shift_enter_prev:
+ e.setAccepted(True)
+ self.shift_enter_pressed.emit()
+ return
+ else:
+ e.setAccepted(True)
+ self.enter_pressed.emit()
+ return
+ return super().keyPressEvent(e)
+
+ def on_text_changed(self):
+ if self.commit_timer is not None:
+ if not self.pre_editing:
+ self.commit_timer.stop()
+ self.commit_timer.start(self.commit_latency)
+ elif not self.pre_editing:
+ self.commit.emit()
+
+ def on_commit_timer_timeout(self):
+ self.commit_timer.stop()
+ self.commit.emit()
+
+ def hideEvent(self, e: QHideEvent) -> None:
+ if self.commit_timer is not None:
+ self.commit_timer.stop()
+ return super().hideEvent(e)
+
+ def inputMethodEvent(self, e: QInputMethodEvent) -> None:
+ if e.preeditString() == '':
+ self.pre_editing = False
+ if self.commit_timer is not None:
+ self.commit_timer.start(self.commit_latency)
+ else:
+ if self.commit_timer is not None:
+ self.commit_timer.stop()
+ self.pre_editing = True
+ return super().inputMethodEvent(e)
+
+
+class PageSearchWidget(Widget):
+
+ search = Signal()
+ replace_all = Signal()
+ replace_one = Signal()
+
+ def __init__(self, parent: QWidget = None, *args, **kwargs) -> None:
+ super().__init__(parent)
+
+ self.search_rstedit_list: List[SourceTextEdit] = []
+ self.search_counter_list: List[int] = []
+ self.highlighter_list: List[HighlightMatched] = []
+ self.counter_sum = 0
+ self.pairwidget_list: List[TransPairWidget] = []
+ self.textblk_item_list: List[TextBlkItem] = []
+
+ self.current_edit: SourceTextEdit = None
+ self.current_cursor: QTextCursor = None
+ self.current_highlighter: HighlightMatched = None
+ self.result_pos = 0
+ self.update_cursor_on_insert = True
+
+ self.search_editor = SearchEditor(self, commit_latency=-1)
+ self.search_editor.setPlaceholderText(self.tr('Find'))
+ self.search_editor.height_changed.connect(self.on_editor_height_changed)
+
+ self.no_result_str = self.tr('No result')
+ self.result_counter_label = QLabel(self.no_result_str)
+ self.result_counter_label.setMaximumHeight(32)
+ self.prev_match_btn = ClickableLabel(None, self)
+ self.prev_match_btn.setObjectName('PrevMatchBtn')
+ self.prev_match_btn.clicked.connect(self.on_prev_search_result)
+ self.prev_match_btn.setToolTip(self.tr('Previous Match (Shift+Enter)'))
+
+ self.next_match_btn = ClickableLabel(None, self)
+ self.next_match_btn.setObjectName('NextMatchBtn')
+ self.next_match_btn.clicked.connect(self.on_next_search_result)
+ self.next_match_btn.setToolTip(self.tr('Next Match (Enter)'))
+
+ self.case_sensitive_toggle = QCheckBox(self)
+ self.case_sensitive_toggle.setObjectName('CaseSensitiveToggle')
+ self.case_sensitive_toggle.setToolTip(self.tr('Match Case'))
+ self.case_sensitive_toggle.clicked.connect(self.on_case_clicked)
+
+ self.whole_word_toggle = QCheckBox(self)
+ self.whole_word_toggle.setObjectName('WholeWordToggle')
+ self.whole_word_toggle.setToolTip(self.tr('Match Whole Word'))
+ self.whole_word_toggle.clicked.connect(self.on_whole_word_clicked)
+
+ self.regex_toggle = QCheckBox(self)
+ self.regex_toggle.setObjectName('RegexToggle')
+ self.regex_toggle.setToolTip(self.tr('Use Regular Expression'))
+ self.regex_toggle.clicked.connect(self.on_regex_clicked)
+
+ self.range_combobox = QComboBox(self)
+ self.range_combobox.addItems([self.tr('Translation'), self.tr('Source'), self.tr('All')])
+ self.range_combobox.currentIndexChanged.connect(self.on_range_changed)
+ self.range_label = QLabel(self)
+ self.range_label.setText(self.tr('Range'))
+
+ self.replace_editor = SearchEditor(self)
+ self.replace_editor.setPlaceholderText(self.tr('Replace'))
+ self.replace_btn = ClickableLabel(None, self)
+ self.replace_btn.setObjectName('ReplaceBtn')
+ self.replace_btn.clicked.connect(self.on_replace_btn_clicked)
+ self.replace_btn.setToolTip(self.tr('Replace'))
+ self.replace_all_btn = ClickableLabel(None, self)
+ self.replace_all_btn.setObjectName('ReplaceAllBtn')
+ self.replace_all_btn.clicked.connect(self.on_replaceall_btn_clicked)
+ self.replace_all_btn.setToolTip(self.tr('Replace All'))
+
+ hlayout_bar1_0 = QHBoxLayout()
+ hlayout_bar1_0.addWidget(self.search_editor)
+ hlayout_bar1_0.addWidget(self.result_counter_label)
+ hlayout_bar1_0.setAlignment(Qt.AlignmentFlag.AlignTop)
+ hlayout_bar1_0.setSpacing(10)
+
+ hlayout_bar1_1 = QHBoxLayout()
+ hlayout_bar1_1.addWidget(self.case_sensitive_toggle)
+ hlayout_bar1_1.addWidget(self.whole_word_toggle)
+ hlayout_bar1_1.addWidget(self.regex_toggle)
+ hlayout_bar1_1.addWidget(self.prev_match_btn)
+ hlayout_bar1_1.addWidget(self.next_match_btn)
+ hlayout_bar1_1.setAlignment(hlayout_bar1_1.alignment() | Qt.AlignmentFlag.AlignTop)
+ hlayout_bar1_1.setSpacing(5)
+
+ hlayout_bar1 = QHBoxLayout()
+ hlayout_bar1.addLayout(hlayout_bar1_0)
+ hlayout_bar1.addLayout(hlayout_bar1_1)
+
+ hlayout_bar2 = QHBoxLayout()
+ hlayout_bar2.addWidget(self.replace_editor)
+ hlayout_bar2.addWidget(self.replace_btn)
+ hlayout_bar2.addWidget(self.replace_all_btn)
+ hlayout_bar2.addStretch()
+ hlayout_bar2.addWidget(self.range_label)
+ hlayout_bar2.addWidget(self.range_combobox)
+ hlayout_bar2.setSpacing(5)
+
+ vlayout = QVBoxLayout(self)
+ vlayout.addLayout(hlayout_bar1)
+ vlayout.addLayout(hlayout_bar2)
+
+ self.search_editor.commit.connect(self.on_commit_search)
+ self.close_btn = ClickableLabel(None, self)
+ self.close_btn.setObjectName('SearchCloseBtn')
+ self.close_btn.setToolTip(self.tr('Close (Escape)'))
+ self.close_btn.clicked.connect(self.on_close_button_clicked)
+ hlayout_bar1_1.addWidget(self.close_btn)
+ e = QGraphicsDropShadowEffect(self)
+ e.setOffset(0, 0)
+ e.setBlurRadius(35)
+ self.setGraphicsEffect(e)
+ self.setFixedWidth(520)
+ self.search_editor.setFixedWidth(200)
+ self.replace_editor.setFixedWidth(200)
+ self.search_editor.enter_pressed.connect(self.on_next_search_result)
+ self.search_editor.shift_enter_pressed.connect(self.on_prev_search_result)
+
+ self.adjustSize()
+
+
+ def on_close_button_clicked(self):
+ self.hide()
+
+ def hideEvent(self, e: QHideEvent) -> None:
+ self.clean_highlighted()
+ return super().hideEvent(e)
+
+ def showEvent(self, e: QShowEvent) -> None:
+ self.search_editor.setFocus()
+ cursor = self.search_editor.textCursor()
+ cursor.movePosition(QTextCursor.MoveOperation.End, QTextCursor.MoveMode.KeepAnchor)
+ self.search_editor.setTextCursor(cursor)
+ text = self.search_editor.toPlainText()
+ if text != '':
+ self.on_commit_search()
+ return super().showEvent(e)
+
+ def on_editor_height_changed(self):
+ self.adjustSize()
+
+ def adjustSize(self) -> None:
+ tgt_size = self.search_editor.height() + self.replace_editor.height() + 30
+ self.setFixedHeight(tgt_size)
+
+ def setReplaceWidgetsVisibility(self, visible: bool):
+ self.replace_editor.setVisible(visible)
+ self.replace_all_btn.setVisible(visible)
+ self.replace_btn.setVisible(visible)
+
+ def clean_highlighted(self):
+ for ii, e in enumerate(self.search_rstedit_list):
+ self.highlighter_list[ii].setEditor(None)
+
+ def clearSearchResult(self):
+ for rst, hightlighter in zip(self.search_rstedit_list, self.highlighter_list):
+ rst.text_changed.disconnect(self.on_rst_text_changed)
+ hightlighter.setDocument(None)
+ self.search_rstedit_list.clear()
+ self.search_counter_list.clear()
+ self.highlighter_list.clear()
+
+ self.current_edit = None
+ self.current_highlighter = None
+ self.current_cursor = None
+ self.updateCounterText()
+
+ def on_rst_text_changed(self):
+ edit: SourceTextEdit = self.sender()
+ if edit.pre_editing or edit.highlighting:
+ return
+
+ idx = self.get_result_edit_index(edit)
+ if idx < 0:
+ return
+
+ highlighter = self.highlighter_list[idx]
+ counter, matched_map = self._match_text(edit.toPlainText())
+
+ delta_count = counter - self.search_counter_list[idx]
+ self.counter_sum += delta_count
+
+ is_current_edit = False
+ before_current = False
+ if edit == self.current_edit:
+ is_current_edit = True
+ elif self.current_edit is not None and self.current_edit_index() > idx:
+ before_current = True
+
+ if counter > 0:
+ self.search_counter_list[idx] = counter
+ if is_current_edit:
+ cursor_end = self.current_cursor.selectionEnd()
+ if cursor_end not in matched_map:
+ matched = self.get_prev_match(cursor_end)
+ if matched is None:
+ self.setCurrentEditor(self.current_edit)
+ else:
+ self.current_cursor.setPosition(matched.start)
+ self.current_cursor.setPosition(matched.end, QTextCursor.MoveMode.KeepAnchor)
+ self.result_pos = matched_map[matched.end].local_no
+ if idx > 0:
+ self.result_pos += sum(self.search_counter_list[ :idx])
+ self.highlight_current_text()
+ else:
+ self.result_pos = matched_map[cursor_end].local_no
+ if idx > 0:
+ self.result_pos += sum(self.search_counter_list[ :idx])
+ self.highlight_current_text()
+ elif before_current:
+ self.result_pos += delta_count
+ highlighter.set_matched_map(matched_map)
+ else:
+ edit = self.search_rstedit_list.pop(idx)
+ self.search_counter_list.pop(idx)
+ edit.text_changed.disconnect(self.on_rst_text_changed)
+ highlighter = self.highlighter_list.pop(idx)
+ highlighter.setEditor(None)
+ if len(self.search_rstedit_list) == 0:
+ self.clearSearchResult()
+ elif self.current_edit is not None:
+ if is_current_edit:
+ if idx >= len(self.search_rstedit_list):
+ self.setCurrentEditor(self.search_rstedit_list[0])
+ else:
+ self.setCurrentEditor(self.search_rstedit_list[idx])
+ elif before_current:
+ self.result_pos += delta_count
+ self.updateCounterText()
+
+ def reInitialize(self):
+ self.clearSearchResult()
+
+ def page_search(self, update_cursor=True):
+
+ self.clean_highlighted()
+ self.clearSearchResult()
+
+ if not self.isVisible():
+ return
+
+ text = self.search_editor.toPlainText()
+ if text == '':
+ self.updateCounterText()
+ return
+
+ search_range = self.range_combobox.currentIndex()
+ search_src = search_range == 1
+ search_trans = search_range == 0
+
+ if search_src:
+ for pw in self.pairwidget_list:
+ self.find_page_text(pw.e_source)
+ elif search_trans:
+ for pw in self.pairwidget_list:
+ self.find_page_text(pw.e_trans)
+ else:
+ for pw in self.pairwidget_list:
+ self.find_page_text(pw.e_source)
+ self.find_page_text(pw.e_trans)
+
+ if len(self.search_counter_list) > 0:
+ self.counter_sum = sum(self.search_counter_list)
+ else:
+ self.counter_sum = 0
+
+ if update_cursor:
+ if len(self.search_rstedit_list) > 0:
+ self.setCurrentEditor(self.search_rstedit_list[0])
+ else:
+ self.updateCounterText()
+
+ def get_regex_pattern(self) -> re.Pattern:
+ target_text = self.search_editor.toPlainText()
+ regexr = target_text
+ if target_text == '':
+ return None
+
+ flag = re.DOTALL
+ if not self.case_sensitive_toggle.isChecked():
+ flag |= re.IGNORECASE
+ if not self.regex_toggle.isChecked():
+ regexr = re.escape(regexr)
+ if self.whole_word_toggle.isChecked():
+ regexr = r'\b' + target_text + r'\b'
+
+ return re.compile(regexr, flag)
+
+ def find_page_text(self, text_edit: QTextEdit):
+ found_counter, pos_map = self._match_text(text_edit.toPlainText())
+ if found_counter > 0:
+ self.search_rstedit_list.append(text_edit)
+ self.search_counter_list.append(found_counter)
+ self.highlighter_list.append(HighlightMatched(text_edit, pos_map))
+ text_edit.text_changed.connect(self.on_rst_text_changed)
+
+ def _match_text(self, text: str) -> Tuple[int, Dict]:
+ try:
+ return match_text(self.get_regex_pattern(), text)
+ except re.error:
+ return 0, {}
+
+ def get_result_edit_index(self, result: SourceTextEdit) -> int:
+ try:
+ return self.search_rstedit_list.index(result)
+ except ValueError:
+ return -1
+
+ def current_edit_index(self) -> int:
+ if self.current_edit is None:
+ return -1
+ return self.get_result_edit_index(self.current_edit)
+
+ def setCurrentEditor(self, edit: SourceTextEdit):
+
+ if type(edit) == SourceTextEdit and self.range_combobox.currentIndex() == 0 \
+ or type(edit) == TransPairWidget and self.range_combobox.currentIndex() == 1:
+ edit = None
+
+ old_idx = self.current_edit_index()
+ self.current_edit = edit
+
+ if edit is None:
+ if len(self.search_rstedit_list) > 0:
+ self.current_edit = self.search_rstedit_list[0]
+ self.current_highlighter = self.highlighter_list[0]
+
+ if self.current_edit is not None:
+ idx = self.current_edit_index()
+ self.current_highlighter = self.highlighter_list[idx]
+ self.updateCurrentCursor()
+ matched_map = self.current_highlighter.matched_map
+ matched: Matched = matched_map[self.current_cursor.selectionEnd()]
+ self.result_pos = matched.local_no
+ if idx > 0:
+ self.result_pos += sum(self.search_counter_list[ :idx])
+ else:
+ self.current_cursor = None
+ self.current_highlighter = None
+
+ self.updateCounterText()
+ self.highlight_current_text(old_idx)
+
+ def updateCurrentCursor(self, intro_cursor=False, backward=False):
+ cursor = self.current_edit.textCursor()
+ text = self.search_editor.toPlainText()
+ if intro_cursor or cursor.selectedText() != text:
+ cursor.clearSelection()
+
+ matched_map = self.current_highlighter.matched_map
+ matched: Matched
+
+ if not cursor.hasSelection():
+ if backward:
+ matched: Matched = matched_map[list(matched_map.keys())[-1]]
+ else:
+ matched: Matched = matched_map[list(matched_map.keys())[0]]
+ cursor.setPosition(matched.start)
+ cursor.setPosition(matched.end, QTextCursor.MoveMode.KeepAnchor)
+ else:
+ sel_start = cursor.selectionStart()
+ for _, matched in matched_map.items():
+ if matched.start >= sel_start:
+ cursor.setPosition(matched.start)
+ cursor.setPosition(matched.end, QTextCursor.MoveMode.KeepAnchor)
+ break
+
+ c_pos = cursor.position()
+ if c_pos not in matched_map:
+ for k, matched in reversed(matched_map.items()):
+ if k < c_pos:
+ cursor.setPosition(matched.start)
+ cursor.setPosition(matched.end, QTextCursor.MoveMode.KeepAnchor)
+ break
+
+ if cursor is not None:
+ if cursor.selectionEnd() not in self.current_highlighter.matched_map:
+ for k, matched in self.current_highlighter.matched_map.items():
+ cursor.setPosition(matched.start)
+ cursor.setPosition(matched.end, QTextCursor.MoveMode.KeepAnchor)
+ break
+
+ self.current_cursor = cursor
+
+ def updateCounterText(self):
+ if self.current_cursor is None or len(self.search_rstedit_list) == 0:
+ self.result_counter_label.setText(self.no_result_str)
+ else:
+ self.result_counter_label.setText(f'{self.result_pos + 1} of {self.counter_sum}')
+
+ def clean_current_selection(self):
+ cursor = self.current_edit.textCursor()
+ if cursor.hasSelection():
+ cursor.clearSelection()
+ self.current_edit.setTextCursor(cursor)
+
+ def get_next_match(self, cursor_sel_start: int) -> Matched:
+ if self.current_highlighter is None:
+ return None
+ matched: Matched
+ for _, matched in self.current_highlighter.matched_map.items():
+ if matched.start > cursor_sel_start:
+ return matched
+ return None
+
+ def get_prev_match(self, cursor_sel_end: int) -> Matched:
+ if self.current_highlighter is None:
+ return None
+ matched: Matched
+ for _, matched in reversed(self.current_highlighter.matched_map.items()):
+ if matched.end < cursor_sel_end:
+ return matched
+ return None
+
+ def move_cursor(self, step: int = 1) -> int:
+ cursor_reset = 0
+ self.clean_current_selection()
+ if step < 0:
+ moved_matched = self.get_prev_match(self.current_cursor.selectionEnd())
+ else:
+ moved_matched = self.get_next_match(self.current_cursor.selectionStart())
+
+ old_idx = -1
+ if moved_matched is None:
+ old_idx = self.current_edit_index()
+ idx = old_idx + step
+ # return step value if next move will be out of page
+ num_rstedit = len(self.search_rstedit_list)
+ if idx >= num_rstedit:
+ cursor_reset = step
+ idx = 0
+ elif idx < 0:
+ cursor_reset = step
+ idx = num_rstedit - 1
+ self.current_edit = self.search_rstedit_list[idx]
+ self.current_highlighter = self.highlighter_list[idx]
+ self.updateCurrentCursor(intro_cursor=True, backward=step < 0)
+ else:
+ self.current_cursor.setPosition(moved_matched.start)
+ self.current_cursor.setPosition(moved_matched.end, QTextCursor.MoveMode.KeepAnchor)
+
+ self.highlight_current_text(old_idx)
+ return cursor_reset
+
+ def highlight_current_text(self, old_idx: int = -1):
+ if self.current_edit is None or not self.current_cursor.hasSelection():
+ return
+
+ idx = self.current_edit_index()
+ if idx != -1:
+ self.highlighter_list[idx].set_current_span(self.current_cursor.selectionStart(), self.current_cursor.selectionEnd())
+
+ if old_idx != -1 and old_idx != idx:
+ self.highlighter_list[old_idx].set_current_span(-1, -1)
+
+ if self.isVisible():
+ self.current_edit.ensure_scene_visible.emit()
+
+ def on_next_search_result(self):
+ if self.current_cursor is None:
+ return
+ move = self.move_cursor(1)
+ if move == 0:
+ self.result_pos = min(self.result_pos + 1, self.counter_sum - 1)
+ else:
+ self.result_pos = 0
+ self.updateCounterText()
+
+ def on_prev_search_result(self):
+ if self.current_cursor is None:
+ return
+ move = self.move_cursor(-1)
+ if move == 0:
+ self.result_pos = max(self.result_pos - 1, 0)
+ else:
+ self.result_pos = self.counter_sum - 1
+ self.updateCounterText()
+
+ def on_whole_word_clicked(self):
+ pcfg.fsearch_whole_word = self.whole_word_toggle.isChecked()
+ self.page_search()
+
+ def on_regex_clicked(self):
+ pcfg.fsearch_regex = self.regex_toggle.isChecked()
+ self.page_search()
+
+ def on_case_clicked(self):
+ pcfg.fsearch_case = self.case_sensitive_toggle.isChecked()
+ self.page_search()
+
+ def on_range_changed(self):
+ pcfg.fsearch_range = self.range_combobox.currentIndex()
+ self.page_search()
+
+ def on_commit_search(self):
+ self.page_search()
+ self.highlight_current_text()
+
+ def on_replaceall_btn_clicked(self):
+ if self.counter_sum > 0:
+ self.replace_all.emit()
+
+ def on_replace_btn_clicked(self):
+ if self.current_cursor is not None:
+ self.replace_one.emit()
+
+ def on_new_textblk(self, idx: int):
+ if self.isVisible():
+ pair_widget = self.pairwidget_list[idx]
+ pair_widget.e_trans.text_changed.connect(self.on_nonrst_edit_text_changed)
+ pair_widget.e_source.text_changed.connect(self.on_nonrst_edit_text_changed)
+
+ def on_nonrst_edit_text_changed(self):
+ edit: SourceTextEdit = self.sender()
+ if not self.isVisible() or edit.pre_editing or edit in self.search_rstedit_list:
+ return
+
+ if type(edit) == SourceTextEdit and self.range_combobox.currentIndex() == 0 \
+ or type(edit) == TransPairWidget and self.range_combobox.currentIndex() == 1:
+ return
+
+ text = self.search_editor.toPlainText()
+ if text == '':
+ return
+
+ found_counter, match_map = self._match_text(edit.toPlainText())
+ if found_counter > 0:
+ current_idx = self.current_edit_index()
+ insert_idx = 0
+ for e in self.search_rstedit_list:
+ if e.idx < edit.idx:
+ insert_idx += 1
+ elif e.idx == edit.idx:
+ if type(edit) == TransTextEdit:
+ insert_idx += 1
+
+ self.search_counter_list.insert(insert_idx, found_counter)
+ self.search_rstedit_list.insert(insert_idx, edit)
+ self.highlighter_list.insert(insert_idx, HighlightMatched(edit, match_map))
+ edit.text_changed.connect(self.on_rst_text_changed)
+ self.counter_sum += found_counter
+
+ if current_idx != -1 and current_idx >= insert_idx:
+ self.result_pos += found_counter
+ self.updateCounterText()
+ else:
+ if self.update_cursor_on_insert:
+ self.result_pos = 0
+ self.setCurrentEditor(edit)
+ else:
+ self.updateCounterText()
\ No newline at end of file
diff --git a/ui/scene_textlayout.py b/ui/scene_textlayout.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2d14b12e2dd923a305277cacd0dfc168e4f30bc
--- /dev/null
+++ b/ui/scene_textlayout.py
@@ -0,0 +1,1087 @@
+import re
+
+from qtpy.QtCore import Qt, QRectF, QPointF, Signal, QSizeF, QSize
+from qtpy.QtGui import QTextCharFormat, QTextDocument, QPixmap, QImage, QTransform, QPalette, QPainter, QTextFrame, QTextBlock, QAbstractTextDocumentLayout, QTextLayout, QFont, QFontMetricsF, QTextOption, QTextLine, QTextFormat
+
+import cv2
+import numpy as np
+from typing import List
+from functools import lru_cache, cached_property
+
+from .misc import pixmap2ndarray, LruIgnoreArg
+from utils import shared as C
+from utils.fontformat import pt2px, FontFormat, LineSpacingType
+
+def print_transform(tr: QTransform):
+ print(f'[[{tr.m11(), tr.m12(), tr.m13()}]\n [{tr.m21(), tr.m22(), tr.m23()}]\n [{tr.m31(), tr.m32(), tr.m33()}]]')
+
+
+PUNSET_HALF = {chr(i) for i in range(0x21, 0x7F)}
+
+# https://www.w3.org/TR/2022/DNOTE-clreq-20220801/#tables_of_chinese_punctuation_marks
+# https://www.w3.org/TR/2022/DNOTE-clreq-20220801/#glyphs_sizes_and_positions_in_character_faces_of_punctuation_marks
+PUNSET_PAUSEORSTOP = {'。', '.', ',', '、', '·', ':', ';', '!', '?'} # dont need to rotate,
+PUNSET_ALIGNCENTER = {'。', '.', ',', '、', '·'}
+PUNSET_BRACKETL = {'「', '『', '“', '‘', '(', '《', '〈', '【', '〖', '〔', '[', '{', '('}
+PUNSET_BRACKETR = {'」', '』', '”', '’', ')', '》', '〉', '】', '〗', '〕', ']', '}', ')'}
+PUNSET_BRACKET = PUNSET_BRACKETL.union(PUNSET_BRACKETR)
+
+PUNSET_NONBRACKET = {'⸺', '…', '⋯', '~', '-', '–', '—', '_', '﹏', '●', '•', '~'}
+PUNSET_VERNEEDROTATE = PUNSET_NONBRACKET.union(PUNSET_BRACKET).union(PUNSET_HALF)
+
+PUNSET_ROTATE_ALIGNL = {'」', '』', '”', '’'}
+PUNSET_ROTATE_ALIGNR = {'「', '『', '“', '‘'}
+
+Dingbats_vertical_aligncenter = r'\u2700-\u275A\u2761-\u2767\u2776-\u27BF'
+Miscellaneous_Symbols_Pattern = r'\u2600-\u26FF' # align center in vertical mode
+
+vertical_force_aligncentel_pattern = re.compile('[' + Dingbats_vertical_aligncenter + Miscellaneous_Symbols_Pattern + r'⁁⁂⁇⁈⁉⁊⁋⁎※⁑⁒⁕⁖⁘⁙⁛⁜‼‽]')
+
+
+@lru_cache
+def vertical_force_aligncentel(char: str) -> bool:
+ return char in PUNSET_PAUSEORSTOP or vertical_force_aligncentel_pattern.match(char) is not None
+
+@lru_cache(maxsize=512)
+def _font_metrics(ffamily: str, size: float, weight: int, italic: bool) -> QFontMetricsF:
+ font = QFont(ffamily, int(size), weight, italic)
+ font.setPointSizeF(size)
+ return QFontMetricsF(font)
+
+@lru_cache(maxsize=2048)
+def get_punc_rect(char: str, ffamily: str, size: float, weight: int, italic: bool) -> List[QRectF]:
+ fm = _font_metrics(ffamily, size, weight, italic)
+ br = [fm.tightBoundingRect(char), fm.boundingRect(char)]
+ return br
+
+@lru_cache(maxsize=2048)
+def get_char_width(char: str, ffamily: str, size: float, weight: int, italic: bool) -> int:
+ fm = _font_metrics(ffamily, size, weight, italic)
+ return fm.horizontalAdvance(char)
+
+def punc_actual_rect(line: QTextLine, family: str, size: float, weight: int, italic: bool, stroke_width: float, h: int = None, w: int = None, space_shift = 0) -> List[int]:
+ if h is None:
+ h = int(line.height())
+ if w is None:
+ w = int(line.naturalTextWidth())
+ pixmap = QImage(w * 2, h * 2, QImage.Format.Format_ARGB32)
+ pixmap.fill(Qt.GlobalColor.transparent)
+ p = QPainter(pixmap)
+ line.draw(p, QPointF(-line.x() - space_shift, -line.y()))
+ p.end()
+ mask = pixmap2ndarray(pixmap, keep_alpha=True)
+ if mask is None:
+ print(f'invalid text line!')
+ return [0, 0, 1, 1]
+ mask = mask[..., -1]
+
+ ar = cv2.boundingRect(cv2.findNonZero(mask))
+ # if stroke_width != 0:
+ ar = np.array(ar, dtype=np.float64)
+ ar[[0, 1]] += stroke_width
+ ar[[2, 3]] -= stroke_width * 2
+ ar = ar.tolist()
+ return ar
+
+@lru_cache(maxsize=2048)
+def punc_actual_rect_cached(cached_args: LruIgnoreArg, char: str, family: str, size: float, weight: int, italic: bool, stroke_width: float, h: int, w: int) -> List[int]:
+ '''
+ char is actually not used, but can be set as some cache flag
+ '''
+ # QtextLine line is invisibale to lru
+ return punc_actual_rect(cached_args.line, family, size, weight, italic, stroke_width, h, w, cached_args.space_shift)
+
+
+class CharFontFormat:
+ def __init__(self, fcmt: QTextCharFormat) -> None:
+ font = fcmt.font()
+ self.font = font
+ self.stroke_width = fcmt.textOutline().widthF() / 2
+ self.font_metrics = QFontMetricsF(font)
+
+ @cached_property
+ def br(self) -> QRectF:
+ # return get_punc_rect('啊', self.family, self.size, self.weight, self.font.italic())[1]
+ _, br1 = get_punc_rect('啊', self.family, self.size, self.weight, self.font.italic())
+ _, br2 = get_punc_rect('木', self.family, self.size, self.weight, self.font.italic())
+ return QRectF(min(br1.left(), br2.left()), br2.top(), max(br1.right(), br2.right()) - min(br1.left(), br2.left()), br2.height())
+
+ @cached_property
+ def tbr(self) -> QRectF:
+ # return get_punc_rect('啊', self.family, self.size, self.weight, self.font.italic())[0]
+ br1, _ = get_punc_rect('啊', self.family, self.size, self.weight, self.font.italic())
+ br2, _ = get_punc_rect('木', self.family, self.size, self.weight, self.font.italic())
+ return QRectF(min(br1.left(), br2.left()), br2.top(), max(br1.right(), br2.right()) - min(br1.left(), br2.left()), br2.height())
+
+ @cached_property
+ def space_width(self) -> int:
+ return get_char_width(' ', self.family, self.size, self.weight, self.font.italic())
+
+ def punc_rect(self, punc: str, family: str = None) -> List[QRectF]:
+ if family is None:
+ family = self.family
+ return get_punc_rect(punc, family, self.size, self.weight, self.font.italic())
+
+ @property
+ def family(self) -> str:
+ return self.font.family()
+
+ @property
+ def weight(self) -> float:
+ return self.font.weight()
+
+ @property
+ def size(self) -> float:
+ return self.font.pointSizeF()
+
+ def punc_actual_rect(self, line: QTextLine, char: str, cache=False, stroke_width=0, h=None, w=None, space_shift=0) -> List[int]:
+ if cache:
+ cached_args = LruIgnoreArg(line=line, space_shift=space_shift)
+ ar = punc_actual_rect_cached(cached_args, char, self.family, self.size, self.weight, self.font.italic(), stroke_width, h, w)
+ else:
+ ar = punc_actual_rect(line, self.family, self.size, self.weight, self.font.italic(), stroke_width, h, w, space_shift)
+ return ar
+
+
+def line_draw_qt6(painter: QPainter, line: QTextLine, x: float, y: float, selected: bool, selection: QAbstractTextDocumentLayout.Selection = None, char_fmt: CharFontFormat = None, char: str = None, line_width: int = None):
+ # some how qt6 line.draw doesn't allow pass FormatRange
+ if selected:
+ qimg = QImage(int(line.naturalTextWidth()), int(line.height()), QImage.Format.Format_ARGB32)
+ qimg.fill(Qt.GlobalColor.transparent)
+ p = QPainter(qimg)
+ line.draw(p, QPointF(-line.x(), -line.y()))
+ p.end()
+ qimg = qimg.convertToFormat(QImage.Format.Format_Alpha8)
+ qimg.reinterpretAsFormat(QImage.Format.Format_Grayscale8)
+ if char_fmt is None:
+ painter.drawImage(QPointF(line.x() + x, line.y() + y), qimg)
+ else:
+ act_rect = char_fmt.punc_actual_rect(line, char, cache=True)
+ tbr = QRectF(0, act_rect[1], line_width, act_rect[3])
+ tgt_rect = QRectF(line.x() + x, line.y() + y + tbr.y(), line_width, tbr.height())
+ painter.drawImage(tgt_rect, qimg, tbr)
+ else:
+ line.draw(painter, QPointF(x, y))
+
+def line_draw_qt5(painter: QPainter, line: QTextLine, x: float, y: float, selected: bool, selection: QAbstractTextDocumentLayout.Selection = None, char_fmt: CharFontFormat = None, char: str = None, line_width: int = None):
+ o = None
+ if selected:
+ o = QTextLayout.FormatRange()
+ o.start = line.textStart()
+ o.length = line.textLength()
+ o.format = selection.format
+ line.draw(painter, QPointF(x, y), o)
+
+
+class SceneTextLayout(QAbstractTextDocumentLayout):
+ size_enlarged = Signal()
+ def __init__(self, doc: QTextDocument, fontformat: FontFormat) -> None:
+ super().__init__(doc)
+ self.max_height = 0
+ self.max_width = 0
+ self.available_width = 0
+ self.available_height = 0
+ self.line_spacing = fontformat.line_spacing
+ self.letter_spacing = fontformat.letter_spacing
+ self.linespacing_type = fontformat.line_spacing_type
+ self.fontformat = fontformat
+
+ self.x_offset_lst = []
+ self.y_offset_lst = []
+
+ self.block_charfmt_lst = []
+ self.block_ideal_width = []
+ self.need_ideal_width = False
+ self.block_ideal_height = []
+ self.need_ideal_height = False
+ self._map_charidx2frag = []
+ self._max_font_size = -1
+
+ self.foreground_pixmap: QPixmap = None
+ self.draw_foreground_only = False
+
+ self.relayout_on_changed = True
+
+ # relative bottom/right
+ self.shrink_height = 0
+ self.shrink_width = 0
+
+ self._doc_text: str = ''
+
+ self._is_painting_stroke = False
+ self._draw_offset = []
+ self.text_padding = 0
+
+ def setMaxSize(self, max_width: int, max_height: int, relayout=True):
+ self.max_height = max_height
+ self.max_width = max_width
+ doc_margin = self.document().documentMargin() * 2
+ self.available_width = max(max_width - doc_margin, 0)
+ self.available_height = max(max_height - doc_margin, 0)
+ if relayout:
+ self.reLayout()
+
+ def setLineSpacing(self, line_spacing: float):
+ if self.line_spacing != line_spacing:
+ self.line_spacing = line_spacing
+ self.reLayout()
+
+ def setLineSpacingType(self, linespacing_type: int):
+ if self.linespacing_type != linespacing_type:
+ self.linespacing_type = linespacing_type
+ self.reLayout()
+
+ def calculate_line_spacing(self, size: float, line_spacing: float = 1):
+ if self.linespacing_type == LineSpacingType.Proportional:
+ return line_spacing * size
+ elif self.linespacing_type == LineSpacingType.Distance:
+ return line_spacing * 10 + size
+ else:
+ raise Exception(f'Invalid line spacing type: {self.linespacing_type}')
+
+ def identity_linespacing(self):
+ if self.linespacing_type == LineSpacingType.Proportional:
+ return 1.
+ elif self.linespacing_type == LineSpacingType.Distance:
+ return 0.
+ else:
+ raise Exception(f'Invalid line spacing type: {self.linespacing_type}')
+
+ def blockBoundingRect(self, block: QTextBlock) -> QRectF:
+ if not block.isValid():
+ return QRectF()
+ br = block.layout().boundingRect()
+ rect = QRectF(0, 0, br.width(), br.height())
+ return rect
+
+ def updateDocumentMargin(self, margin):
+ doc_margin = self.document().documentMargin()
+ dm = margin - doc_margin
+ doc_margin *= 2
+ self.document().setDocumentMargin(margin)
+ margin *= 2
+ self.max_height = margin + self.available_height
+ self.max_width = margin + self.available_width
+
+ def documentSize(self) -> QSizeF:
+ return QSizeF(self.max_width, self.max_height)
+
+ def documentChanged(self, position: int, charsRemoved: int, charsAdded: int) -> None:
+ if not self.relayout_on_changed:
+ return
+ self.reLayoutEverything()
+
+ def reLayoutEverything(self):
+ self._doc_text = self.document().toPlainText()
+ self._max_font_size = -1
+ block = self.document().firstBlock()
+ self.block_charfmt_lst = []
+ self.block_ideal_width = []
+ self.block_ideal_height = []
+ self._map_charidx2frag = []
+ while block.isValid():
+ charfmt_lst, ideal_width, char_idx = [], -1, 0
+ ideal_height = 0
+ charidx_map = {}
+ it = block.begin()
+ frag_idx = 0
+ while not it.atEnd():
+ fragment = it.fragment()
+ fcmt = fragment.charFormat()
+ cfmt = CharFontFormat(fcmt)
+ charfmt_lst.append(cfmt)
+ if cfmt.size > self._max_font_size:
+ self._max_font_size = cfmt.size
+
+ if self.need_ideal_width:
+ w_ = cfmt.br.width()
+ if ideal_width < w_:
+ ideal_width = w_
+
+ if self.need_ideal_height:
+ h_ = cfmt.punc_rect('木fg')[0].height()
+ if ideal_height < h_:
+ ideal_height = h_
+
+ text_len = fragment.length()
+ for _ in range(text_len):
+ charidx_map[char_idx] = frag_idx
+ char_idx += 1
+ it += 1
+ frag_idx += 1
+
+ self.block_charfmt_lst.append(charfmt_lst)
+ self.block_ideal_width.append(ideal_width)
+ self.block_ideal_height.append(ideal_height)
+ self._map_charidx2frag.append(charidx_map)
+ block = block.next()
+ self.reLayout()
+
+ def max_font_size(self, to_px=False) -> float:
+ fs = self._max_font_size if self._max_font_size > 0 else self.document().defaultFont().pointSizeF()
+ if to_px:
+ fs = pt2px(fs)
+ return fs
+
+ def minSize(self):
+ return (self.shrink_height + self.text_padding, self.shrink_width + self.text_padding)
+
+ def get_char_fontfmt(self, block_number: int, char_idx: int) -> CharFontFormat:
+ charidx2frag_map = self._map_charidx2frag[block_number]
+ if len(charidx2frag_map) == 0:
+ return None
+ if char_idx not in charidx2frag_map: # caused by inputmethod
+ char_idx = len(charidx2frag_map) - 1
+ frag_idx = charidx2frag_map[char_idx]
+ return self.block_charfmt_lst[block_number][frag_idx]
+
+
+class VerticalTextDocumentLayout(SceneTextLayout):
+
+ def __init__(self, doc: QTextDocument, fontformat: FontFormat):
+ super().__init__(doc, fontformat)
+
+ self.line_spaces_lst = []
+ self.min_height = 0
+ self.layout_left = 0
+ self.force_single_char = True
+ self.has_selection = False
+ self.draw_shifted = 0
+
+ self.need_ideal_width = True
+ self.line_draw = line_draw_qt6 if C.FLAG_QT6 else line_draw_qt5
+
+ self.per_char_records = []
+
+ @property
+ def align_right(self):
+ return False
+
+ def reLayout(self):
+ self.min_height = 0
+ self.layout_left = 0
+ self.line_spaces_lst = []
+ self.per_char_records = []
+ self.draw_shifted = 0
+ self.shrink_height = 0
+ self.shrink_width = 0
+ self.text_padding = 0
+ doc = self.document()
+ doc_margin = doc.documentMargin()
+ block = doc.firstBlock()
+ while block.isValid():
+ self.layoutBlock(block)
+ block = block.next()
+
+ enlarged = False
+ x_shift = 0
+ if self.layout_left < doc_margin:
+ x_shift = doc_margin - self.layout_left
+ self.max_width += x_shift
+ self.available_width = self.max_width - 2*doc_margin
+ enlarged = True
+ if self.min_height - doc_margin > self.available_height:
+ self.available_height = self.min_height - doc_margin
+ self.max_height = self.available_height + doc_margin * 2
+ enlarged = True
+ if enlarged:
+ self.size_enlarged.emit()
+ if x_shift != 0:
+ block = doc.firstBlock()
+ while block.isValid():
+ tl = block.layout()
+ for ii in range(tl.lineCount()):
+ line = tl.lineAt(ii)
+ line_pos = line.position()
+ line_pos.setX(x_shift + line_pos.x())
+ line.setPosition(line_pos)
+ block = block.next()
+ for ii, xoffset in enumerate(self.x_offset_lst):
+ self.x_offset_lst[ii] = xoffset + x_shift
+ self.updateDrawOffsets()
+ self.documentSizeChanged.emit(QSizeF(self.max_width, self.max_height))
+
+ def updateDrawOffsets(self):
+ if self._is_painting_stroke and len(self._draw_offset) > 0:
+ return
+ self._draw_offset.clear()
+ doc = self.document()
+ block = doc.firstBlock()
+ while block.isValid():
+ blk_no = block.blockNumber()
+ _draw_offsets = []
+ self._draw_offset.append(_draw_offsets)
+
+ layout = block.layout()
+ blk_text = block.text()
+ blk_text_len = len(blk_text)
+
+ line_spaces_lst = self.line_spaces_lst[blk_no]
+ char_records = self.per_char_records[blk_no]
+
+ for ii in range(layout.lineCount()):
+ xy_offsets = [0, 0]
+ _draw_offsets.append(xy_offsets)
+
+ line = layout.lineAt(ii)
+ if line.textLength() == 0:
+ continue
+ num_rspaces, num_lspaces, _, line_pos = line_spaces_lst[ii]
+ char_idx = min(line_pos + num_lspaces, blk_text_len - 1)
+ if char_idx < 0:
+ continue
+
+ char = blk_text[char_idx]
+ cfmt = self.get_char_fontfmt(blk_no, char_idx)
+
+ line_width = -1
+ if char_idx in char_records:
+ line_width = char_records[char_idx]['line_width']
+ if line_width < 0:
+ line_width = cfmt.tbr.width()
+
+ space_shift = 0
+ if num_lspaces > 0:
+ space_shift = num_lspaces * cfmt.space_width
+
+ if char in PUNSET_VERNEEDROTATE:
+ char = blk_text[char_idx]
+ if char.isalpha():
+ xoff = 0
+ yoff = -line.ascent() - (line_width - cfmt.font_metrics.capHeight()) / 2
+
+ else: # () ()
+ non_bracket_br = cfmt.punc_actual_rect(line, char, cache=True, space_shift=space_shift)
+ yoff = -non_bracket_br[1] - non_bracket_br[3]
+ if char in PUNSET_BRACKETL:
+ xoff = 0
+ else:
+ xoff = -non_bracket_br[0]
+
+ if char in PUNSET_ROTATE_ALIGNL:
+ yoff = yoff
+ elif char in PUNSET_ROTATE_ALIGNR:
+ yoff = yoff - (line_width - non_bracket_br[3])
+ else:
+ yoff = yoff - (line_width - non_bracket_br[3]) / 2
+
+ else:
+ # other characters will simply be aligned center for this line
+ act_rect = cfmt.punc_actual_rect(line, char, cache=True, space_shift=space_shift)
+ if vertical_force_aligncentel(char):
+ yoff = -act_rect[1]
+ else:
+ yoff = min(cfmt.br.top() - cfmt.tbr.top(), -cfmt.tbr.top() - line.ascent())
+ xoff = -act_rect[0] + (line_width - act_rect[2]) / 2
+ # if char in PUNSET_ALIGNTOP:
+ # yoff = yoff + (cfmt.tbr.height() - act_rect[3]) / 2
+
+ if num_lspaces > 0:
+ xoff -= space_shift
+ yoff += space_shift
+
+ if char in PUNSET_ALIGNCENTER:
+ tbr, br = cfmt.punc_rect(char)
+ yoff += (tbr.height() + cfmt.font_metrics.descent() - act_rect[3]) / 2
+
+ # else:
+ # empty_spacing = num_lspaces * cfmt.space_width
+ # if TEXTLAYOUT_QTVERSION:
+ # xshift = max(line.naturalTextWidth() - cfmt.br.width(), 0)
+ # else:
+ # xshift = empty_spacing
+
+ # xoff = -xshift
+ # yoff = min(cfmt.br.top() - cfmt.tbr.top(), -cfmt.tbr.top() - line.ascent()) + empty_spacing
+
+ xy_offsets[0], xy_offsets[1] = xoff, yoff
+ block = block.next()
+
+
+ def draw(self, painter: QPainter, context: QAbstractTextDocumentLayout.PaintContext) -> None:
+ doc = self.document()
+ painter.save()
+ block = doc.firstBlock()
+ cursor_block = None
+ context_sel = context.selections
+ has_selection = False
+ selection = None
+ if len(context_sel) > 0:
+ has_selection = True
+ selection = context_sel[0]
+
+
+ while block.isValid():
+ blk_no = block.blockNumber()
+ blpos, bllen = block.position(), block.length()
+ layout = block.layout()
+ blk_text = block.text()
+ blk_text_len = len(blk_text)
+ char_records = self.per_char_records[blk_no]
+
+ line_spaces_lst = self.line_spaces_lst[blk_no]
+
+ if context.cursorPosition >= blpos and context.cursorPosition < blpos + bllen:
+ cursor_block = block
+
+ for ii in range(layout.lineCount()):
+ line = layout.lineAt(ii)
+ if line.textLength() == 0:
+ continue
+ num_rspaces, num_lspaces, _, line_pos = line_spaces_lst[ii]
+ char_idx = min(line_pos + num_lspaces, blk_text_len - 1)
+ if char_idx < 0:
+ line.draw(painter, QPointF(0, 0))
+ continue
+
+ xoff, yoff = self._draw_offset[blk_no][ii]
+
+ char = blk_text[char_idx]
+ cfmt = self.get_char_fontfmt(blk_no, char_idx)
+ fm = cfmt.font_metrics
+ selected = False
+ if has_selection:
+ sel_start = selection.cursor.selectionStart() - blpos
+ sel_end = selection.cursor.selectionEnd() - blpos
+ if char_idx < sel_end and char_idx >= sel_start:
+ selected = True
+
+ line_width = -1
+ if char_idx in char_records:
+ line_width = char_records[char_idx]['line_width']
+ if line_width < 0:
+ line_width = cfmt.tbr.width()
+
+ if char in PUNSET_VERNEEDROTATE:
+ line_x, line_y = line.x(), line.y()
+ y_x = line_y - line_x
+ y_p_x = line_y + line_x
+ transform = QTransform(0, 1, 0, -1, 0, 0, y_p_x, y_x, 1)
+ inv_transform = QTransform(0, -1, 0, 1, 0, 0, -y_x, y_p_x, 1)
+ painter.setTransform(transform, True)
+ self.line_draw(painter, line, xoff, yoff, selected, selection, char_fmt=None)
+ painter.setTransform(inv_transform, True)
+ else:
+ self.line_draw(painter, line, xoff, yoff, selected, selection, char_fmt=cfmt, char=char, line_width=line_width)
+
+ block = block.next()
+
+ if self.foreground_pixmap is not None:
+ painter.drawPixmap(0, 0, self.foreground_pixmap)
+
+ if cursor_block is not None:
+ block = cursor_block
+ blk_text = block.text()
+ blpos = block.position()
+ bllen = block.length()
+ blk_no = block.blockNumber()
+ layout = block.layout()
+ if context.cursorPosition < -1:
+ cpos = layout.preeditAreaPosition() - (cpos + 2)
+ else:
+ cpos = context.cursorPosition - blpos
+
+ line = layout.lineForTextPosition(cpos)
+ if line.isValid():
+
+ pos = line.position()
+ x, y = pos.x(), pos.y()
+ if line.textLength() == 0:
+ fm = QFontMetricsF(block.charFormat().font())
+ else:
+ num_rspaces, num_lspaces, char_yoffset_lst, line_pos = self.line_spaces_lst[blk_no][line.lineNumber()]
+ yidx = cpos - line_pos
+ if yidx >= 0 < len(char_yoffset_lst):
+ y = char_yoffset_lst[yidx]
+
+ painter.setCompositionMode(QPainter.CompositionMode.RasterOp_NotDestination)
+ painter.fillRect(QRectF(x, y, fm.height(), 2), painter.pen().brush())
+ if self.has_selection == has_selection:
+ if C.USE_PYSIDE6:
+ self.update.emit()
+ else:
+ self.update.emit(QRectF(x, y, fm.height(), 2))
+ else:
+ if C.USE_PYSIDE6:
+ self.update.emit()
+ else:
+ self.update.emit(QRectF(0, 0, self.max_width, self.max_height))
+ self.has_selection = has_selection # update this flag when drawing the cursor
+ painter.restore()
+
+ def hitTest(self, point: QPointF, accuracy: Qt.HitTestAccuracy) -> int:
+ blk = self.document().firstBlock()
+ x, y = point.x(), point.y()
+ off = 0
+ while blk.isValid():
+ blk_no = blk.blockNumber()
+ blk_char_yoffset = self.y_offset_lst[blk_no]
+ nyoffset = len(blk_char_yoffset)
+ rect = blk.layout().boundingRect()
+ rect_left = rect.left()
+ rect_right = rect.right()
+ rect_right, rect_left = self.x_offset_lst[blk_no], self.x_offset_lst[blk_no+1]
+ if rect_left <= x and rect_right >= x:
+ layout = blk.layout()
+ for ii in range(layout.lineCount()):
+ line_top, line_bottom = blk_char_yoffset[min(nyoffset - 1, ii)]
+ line = layout.lineAt(ii)
+ line_xy = line.position()
+ if not line_xy.x() <= x:
+ continue
+ if line_top > y:
+ off = min(off, line.textStart())
+ elif line_bottom < y:
+ off = max(off, line.textStart() + line.textLength())
+ else:
+ num_rspaces, num_lspaces, char_yoffset_lst, line_pos = self.line_spaces_lst[blk_no][ii]
+ if num_rspaces > 0 or num_lspaces > 0:
+ for ii, (ytop, ybottom) in enumerate(zip(char_yoffset_lst[:-1], char_yoffset_lst[1:])):
+ dis_top, dis_bottom = y - ytop, ybottom - y
+ if dis_top >= 0 and dis_bottom >= 0:
+ off = ii + line_pos if dis_top < dis_bottom else ii + 1 + line_pos
+ break
+ break
+ else:
+ ntr = line.naturalTextRect()
+ off = line.textStart()
+ if line.textLength() != 1:
+ if line_bottom - y < y - line_top:
+ off += 2
+ elif ntr.right() - x < x - ntr.left():
+ off += 1
+ elif line_bottom - y < y - line_top:
+ off += 1
+ break
+ break
+ blk = blk.next()
+ return blk.position() + off
+
+ def layoutBlock(self, block: QTextBlock):
+ doc = self.document()
+ ls = self.letter_spacing
+
+ block.clearLayout()
+ doc_margin = doc.documentMargin()
+ line_y_offset = doc_margin
+ blk_char_yoffset = []
+ blk_line_spaces = []
+
+ block_no = block.blockNumber()
+ is_final_block = block == doc.lastBlock()
+ blk_text = block.text()
+ blk_text_len = len(blk_text)
+ if blk_text_len != 0:
+ block_width = self.block_ideal_width[block_no]
+ else:
+ block_width = CharFontFormat(block.charFormat()).tbr.width()
+
+ layout_first_block = block == doc.firstBlock()
+ if layout_first_block:
+ x_offset = self.max_width - doc_margin
+ self.x_offset_lst = [self.max_width - doc_margin]
+ self.y_offset_lst = []
+ else:
+ x_offset = self.x_offset_lst[-1]
+
+ char_idx = 0
+ tl = block.layout()
+ tl.beginLayout()
+ option = doc.defaultTextOption()
+ option.setWrapMode(QTextOption.WrapAnywhere)
+ tl.setTextOption(option)
+
+ shrink_height = 0
+ width_list = []
+ line_not_set = []
+ ypos_list = []
+ is_first_line = block_no == 0
+ char_records = {}
+ line_char_ids = []
+
+ while True:
+ line = tl.createLine()
+ if not line.isValid():
+ break
+
+ line.setLineWidth(block_width)
+ line.setNumColumns(1)
+
+ available_height = self.available_height + doc_margin
+ text_len = line.textLength()
+ end_char = char_idx + text_len >= blk_text_len
+
+ if char_idx + text_len > blk_text_len:
+ ypos = ypos_list[-1] if len(ypos_list) > 0 else 0
+ blk_line_spaces.append([0, 0, [ypos], char_idx])
+ line.setPosition(QPointF(x_offset - block_width, ypos))
+ continue
+
+ num_rspaces, num_lspaces = 0, 0
+ text = blk_text[char_idx: char_idx + text_len].replace('\n', '')
+ num_rspaces = text_len - len(text.rstrip())
+ num_lspaces = text_len - len(text.lstrip())
+
+ tbr_h = space_w = let_sp_offset = 0
+ char_idx += num_lspaces
+ single_char_h = None
+
+ if char_idx < blk_text_len:
+ cfmt = self.get_char_fontfmt(block_no, char_idx)
+ space_shift = 0
+ if num_lspaces > 0:
+ space_shift = num_lspaces * cfmt.space_width
+ line_char_ids.append(char_idx)
+ space_w = cfmt.space_width
+ let_sp_offset = cfmt.tbr.height() * (ls - 1)
+
+ tbr_h = cfmt.tbr.height() + let_sp_offset
+ char = blk_text[char_idx]
+ if char in PUNSET_VERNEEDROTATE:
+ tbr, br = cfmt.punc_rect(char)
+ single_char_h = tbr.width()
+ tbr_h = tbr.width() * text_len
+ if char.isalpha():
+ cw2 = cfmt.punc_rect(char+char)[1].width()
+ tbr_h = br.width() - (br.width() * 2 - cw2)
+ elif char in {'…', '⋯', '—', '~'}:
+ tbr_h = line.naturalTextWidth() - num_lspaces * space_w
+ next_char_idx = char_idx + 1
+ if next_char_idx < blk_text_len and blk_text[next_char_idx] == char:
+ tbr_h -= let_sp_offset
+ else:
+ tbr_h = line.naturalTextWidth() - num_lspaces * space_w
+ tbr_h += let_sp_offset
+ elif vertical_force_aligncentel(char):
+ if char not in PUNSET_ALIGNCENTER:
+ tbr_h = cfmt.punc_actual_rect(line, char, cache=True, space_shift=space_shift)[3]
+ else:
+ tbr, br = cfmt.punc_rect(char)
+ tbr_h = tbr.height() + cfmt.font_metrics.descent()
+ tbr_h += let_sp_offset
+ elif char_idx - num_lspaces < blk_text_len:
+ cfmt = self.get_char_fontfmt(block_no, char_idx - num_lspaces)
+ tbr_h = cfmt.tbr.height() + cfmt.font_metrics.descent()
+ space_w = cfmt.space_width
+
+ if num_lspaces == 0 and tbr_h != 0:
+ ntw = line.naturalTextWidth()
+ shifted = ntw - cfmt.br.width()
+ if is_final_block:
+ self.draw_shifted = max(self.draw_shifted, shifted)
+
+ char_yoffset_lst = [line_y_offset]
+ for _ in range(num_lspaces):
+ char_yoffset_lst.append(min(available_height - tbr_h, char_yoffset_lst[-1] + space_w))
+ blk_line_spaces.append([num_rspaces, num_lspaces, char_yoffset_lst, char_idx - num_lspaces])
+
+ char_bottom = char_yoffset_lst[-1] + tbr_h
+ out_of_vspace = char_bottom - max(let_sp_offset, 0) > available_height
+ if out_of_vspace:
+ # switch to next line
+ if char_idx == 0 and layout_first_block:
+ self.min_height = doc_margin + tbr_h
+
+ line_y_offset = doc_margin
+
+ char_yoffset_lst[-1] = line_y_offset
+ char_yoffset_lst.append(line_y_offset + tbr_h)
+ for _ in range(num_rspaces):
+ char_yoffset_lst.append(min(char_yoffset_lst[-1] + space_w, available_height))
+ line_bottom = char_yoffset_lst[-1]
+ else:
+ cfmt = self.get_char_fontfmt(block_no, char_idx)
+ if cfmt is not None:
+ width_list.append(cfmt.tbr.width())
+ else:
+ width_list.append(-1)
+
+ char_yoffset_lst.append(char_bottom)
+ for _ in range(num_rspaces):
+ char_yoffset_lst.append(min(char_yoffset_lst[-1] + space_w, available_height))
+ line_bottom = char_yoffset_lst[-1]
+ shrink_height = max(shrink_height, line_bottom)
+
+ ypos_list.append(line_y_offset)
+ line_not_set.append(line)
+ if out_of_vspace or end_char:
+ if is_first_line:
+ line_spacing = self.identity_linespacing()
+ else:
+ line_spacing = self.line_spacing
+ if len(width_list) == 0:
+ width_list = [block_width]
+ end_line, end_ypos, end_w = line, line_y_offset, width_list[-1]
+ idea_line_width = -1
+ if out_of_vspace and end_char and len(width_list) > 1:
+ idea_line_width = max(width_list[:-1])
+ else:
+ idea_line_width = max(width_list)
+ if idea_line_width == -1:
+ idea_line_width = block_width
+
+ if len(line_char_ids) == 0:
+ line_char_ids = [char_idx]
+ end_char_id = line_char_ids[-1]
+ for cidx in line_char_ids:
+ char_records[cidx] = {'line_width': idea_line_width}
+ line_char_ids = []
+
+ x_offset = x_offset - self.calculate_line_spacing(idea_line_width, line_spacing)
+
+ for line, ypos in zip(line_not_set[:-1], ypos_list[:-1]):
+ line.setPosition(QPointF(x_offset, ypos))
+ if out_of_vspace:
+ if end_char:
+ if not len(line_not_set) == 1:
+ x_offset = x_offset - self.calculate_line_spacing(end_w, line_spacing)
+ end_line.setPosition(QPointF(x_offset, end_ypos))
+ char_records[end_char_id] = {'line_width': end_w}
+ else:
+ line_not_set = [end_line]
+ ypos_list = [end_ypos]
+ width_list = [end_w]
+ line_char_ids = [end_char_id]
+ else:
+ end_line.setPosition(QPointF(x_offset, end_ypos))
+
+ if out_of_vspace:
+ is_first_line = False
+
+ strip_space_textlen = text_len - num_lspaces
+ if strip_space_textlen > 1 and single_char_h is not None:
+ for ii in range(strip_space_textlen - 1):
+ blk_char_yoffset.append([line_y_offset + ii * single_char_h, line_y_offset + (ii + 1) * single_char_h])
+ blk_char_yoffset.append([blk_char_yoffset[-1][1], line_bottom])
+ else:
+ blk_char_yoffset.append([line_y_offset, line_bottom])
+
+ line_y_offset = max(line_bottom, doc_margin)
+ char_idx += text_len - num_lspaces
+ tl.endLayout()
+
+ self.layout_left = x_offset - self.draw_shifted
+ self.shrink_width = max(self.max_width - self.layout_left - doc_margin + 0.01, self.shrink_width)
+ self.shrink_height = max(shrink_height + 0.01 - doc_margin, self.shrink_height)
+ self.x_offset_lst.append(x_offset)
+ self.y_offset_lst.append(blk_char_yoffset)
+ self.line_spaces_lst.append(blk_line_spaces)
+ self.per_char_records.append(char_records)
+
+ def frameBoundingRect(self, frame: QTextFrame):
+ return QRectF(0, 0, max(self.document().pageSize().width(), self.max_width), 2147483647)
+
+ def setLetterSpacing(self, letter_spacing: float):
+ if self.letter_spacing != letter_spacing:
+ self.letter_spacing = letter_spacing
+ self.reLayout()
+
+
+
+class HorizontalTextDocumentLayout(SceneTextLayout):
+
+ def __init__(self, doc: QTextDocument, fontformat: FontFormat):
+ super().__init__(doc, fontformat)
+ self.need_ideal_height = True
+
+ def reLayout(self):
+ doc = self.document()
+ doc_margin = self.document().documentMargin()
+ self.text_padding = 0
+ self.shrink_height = 0
+ self.shrink_width = 0
+ block = doc.firstBlock()
+ while block.isValid():
+ self.layoutBlock(block)
+ block = block.next()
+
+ if len(self.y_offset_lst) > 0:
+ new_height = self.shrink_height
+ else:
+ new_height = doc_margin
+ if new_height > self.available_height:
+ self.max_height = new_height + doc_margin * 2
+ self.available_height = new_height
+ self.size_enlarged.emit()
+
+ if doc.defaultTextOption().alignment() == Qt.AlignmentFlag.AlignCenter:
+ block = doc.firstBlock()
+ y_offset = (self.max_height - new_height) / 2 - doc_margin
+ while block.isValid():
+ tl = block.layout()
+ for ii in range(tl.lineCount()):
+ line = tl.lineAt(ii)
+ line_pos = line.position()
+ line_pos.setY(y_offset + line_pos.y())
+ line.setPosition(line_pos)
+ block = block.next()
+
+ self.documentSizeChanged.emit(QSizeF(self.max_width, self.max_height))
+
+ def hitTest(self, point: QPointF, accuracy: Qt.HitTestAccuracy) -> int:
+ blk = self.document().firstBlock()
+ x, y = point.x(), point.y()
+ off = 0
+ while blk.isValid():
+ rect = blk.layout().boundingRect()
+ if rect.top() <= y and rect.bottom() >= y:
+ layout = blk.layout()
+ for ii in range(layout.lineCount()):
+ line = layout.lineAt(ii)
+ ntr = line.naturalTextRect()
+ if ntr.top() < y and ntr.bottom() >= y:
+ off = line.xToCursor(point.x(), QTextLine.CursorBetweenCharacters)
+ break
+ elif ntr.left() > x:
+ off = min(off, line.textStart())
+ else:
+ off = max(off, line.textStart() + line.textLength())
+ break
+ blk = blk.next()
+ return blk.position() + off
+
+ def frameBoundingRect(self, frame: QTextFrame):
+ return QRectF(0, 0, max(self.document().pageSize().width(), self.max_width), 2147483647)
+
+ def layoutBlock(self, block: QTextBlock):
+ doc = self.document()
+ block.clearLayout()
+ tl = block.layout()
+
+ option = doc.defaultTextOption()
+ # maybe an option for it
+ option.setWrapMode(QTextOption.WrapMode.WrapAtWordBoundaryOrAnywhere)
+ tl.setTextOption(option)
+ font = block.charFormat().font()
+
+ # fm = QFontMetrics(font)
+ doc_margin = self.document().documentMargin()
+
+ block_height = self.block_ideal_height[block.blockNumber()]
+ if block_height == 0:
+ tbr, br = get_punc_rect('木fg', font.family(), font.pointSizeF(), font.weight(), font.italic())
+ block_height = tbr.height()
+ if block == doc.firstBlock():
+ self.x_offset_lst = []
+ self.y_offset_lst = []
+ # y_offset = -tbr.top() - fm.ascent() + doc_margin
+ # y_offset = min(br.top() - tbr.top(), -tbr.top() - fm.ascent()) + doc_margin
+ y_offset = doc_margin
+ else:
+ y_offset = self.y_offset_lst[-1]
+
+ line_idx = 0
+ tl.beginLayout()
+ shrink_width = 0
+ char_idx = 0
+ blk_no = block.blockNumber()
+ is_last_block = blk_no == self.document().blockCount() - 1
+ is_first_block = blk_no == 0
+ text_padding = 0
+ is_first_line = False
+
+ while True:
+ line = tl.createLine()
+ if not line.isValid():
+ break
+ # line.setLeadingIncluded(False)
+ line.setLineWidth(self.available_width)
+ nchar = line.textLength()
+
+ dy = 0
+ idea_height = -1
+ if nchar > 0:
+ tgt_cfmt = None
+ tgt_size = -1
+ for ii in range(nchar):
+ cfmt = self.get_char_fontfmt(blk_no, char_idx + ii)
+ if cfmt is None:
+ break
+ sz = cfmt.font.pointSizeF()
+ if sz > tgt_size:
+ tgt_size = sz
+ tgt_cfmt = cfmt
+ if tgt_cfmt is not None:
+ font = tgt_cfmt.font
+ tbr, br = get_punc_rect('木fg', font.family(), font.pointSizeF(), font.weight(), font.italic())
+ dy = -tbr.top() - line.ascent()
+ idea_height = tbr.height()
+
+ if idea_height == -1:
+ idea_height = block_height
+
+ line.setPosition(QPointF(doc_margin, y_offset + dy))
+ tw = line.naturalTextWidth()
+ shrink_width = max(tw, shrink_width)
+ self.shrink_height = max(idea_height + y_offset - doc_margin, self.shrink_height) #????
+ y_offset += self.calculate_line_spacing(idea_height, self.line_spacing)
+ line_idx += 1
+ char_idx += nchar
+ if is_first_block and is_first_line:
+ text_padding = max(text_padding, idea_height)
+ elif is_last_block:
+ text_padding = idea_height
+ is_first_line = False
+
+ tl.endLayout()
+
+ if is_first_block or is_last_block:
+ self.text_padding = max(self.text_padding, text_padding / 2)
+ self.y_offset_lst.append(y_offset)
+ self.shrink_width = max(shrink_width, self.shrink_width)
+ return 1
+
+ def draw(self, painter: QPainter, context: QAbstractTextDocumentLayout.PaintContext) -> None:
+ doc = self.document()
+ painter.save()
+ painter.setPen(context.palette.color(QPalette.ColorRole.Text))
+ block = doc.firstBlock()
+ cursor_block = None
+ while block.isValid():
+ blpos = block.position()
+ layout = block.layout()
+ bllen = block.length()
+ if context.cursorPosition >= blpos and context.cursorPosition < blpos + bllen:
+ cursor_block = block
+ layout = block.layout()
+ blpos = block.position()
+ bllen = block.length()
+ selections = []
+ for sel in context.selections:
+ selStart = sel.cursor.selectionStart() - blpos
+ selEnd = sel.cursor.selectionEnd() - blpos
+ if selStart < bllen and selEnd > 0 and selEnd > selStart:
+ o = QTextLayout.FormatRange()
+ o.start = selStart
+ o.length = selEnd - selStart
+ o.format = sel.format
+ selections.append(o)
+ elif not sel.cursor.hasSelection() \
+ and sel.format.hasProperty(QTextFormat.FullWidthSelection) \
+ and block.contains(sel.cursor.position()):
+ o = QTextLayout.FormatRange()
+ l = layout.lineForTextPosition(sel.cursor.position() - blpos)
+ o.start = l.textStart()
+ o.length = l.textLength()
+ if o.start + o.length == bllen - 1:
+ ++o.length
+ o.format = sel.format
+ selections.append(o)
+ clip = context.clip if context.clip.isValid() else QRectF()
+ layout.draw(painter, QPointF(0, 0), selections, clip)
+ block = block.next()
+
+ if self.foreground_pixmap is not None:
+ painter.drawPixmap(0, 0, self.foreground_pixmap)
+
+ if cursor_block is not None:
+ block = cursor_block
+ blpos = block.position()
+ bllen = block.length()
+ layout = block.layout()
+ if context.cursorPosition < -1:
+ cpos = layout.preeditAreaPosition() - (cpos + 2)
+ else:
+ cpos = context.cursorPosition - blpos
+ layout.drawCursor(painter, QPointF(0, 0), cpos, 1)
+ painter.restore()
\ No newline at end of file
diff --git a/ui/scenetext_manager.py b/ui/scenetext_manager.py
new file mode 100644
index 0000000000000000000000000000000000000000..0fa083b291559b85bdf433f14551d93a00c9c7f3
--- /dev/null
+++ b/ui/scenetext_manager.py
@@ -0,0 +1,1138 @@
+
+from typing import List, Union, Tuple
+import numpy as np
+import copy
+
+from qtpy.QtWidgets import QApplication, QWidget, QGraphicsItem
+from qtpy.QtCore import QObject, QRectF, Qt, Signal, QPointF, QPoint
+from qtpy.QtGui import QKeyEvent, QTextCursor, QFontMetricsF, QFont, QTextCharFormat, QClipboard
+try:
+ from qtpy.QtWidgets import QUndoCommand
+except:
+ from qtpy.QtGui import QUndoCommand
+
+from .textitem import TextBlkItem, TextBlock
+from .canvas import Canvas
+from .textedit_area import TransTextEdit, SourceTextEdit, TransPairWidget, SelectTextMiniMenu, TextEditListScrollArea, QVBoxLayout, Widget
+from utils.fontformat import FontFormat
+from .textedit_commands import propagate_user_edit, TextEditCommand, ReshapeItemCommand, MoveBlkItemsCommand, AutoLayoutCommand, ApplyFontformatCommand, RotateItemCommand, TextItemEditCommand, TextEditCommand, PageReplaceOneCommand, PageReplaceAllCommand, MultiPasteCommand, ResetAngleCommand, SqueezeCommand
+from .text_panel import FontFormatPanel
+from utils.config import pcfg
+from utils import shared
+from utils.imgproc_utils import extract_ballon_region, rotate_polygons, get_block_mask
+from utils.text_processing import seg_text, is_cjk
+from utils.text_layout import layout_text
+
+
+class CreateItemCommand(QUndoCommand):
+ def __init__(self, blk_item: TextBlkItem, ctrl, parent=None):
+ super().__init__(parent)
+ self.blk_item = blk_item
+ self.ctrl: SceneTextManager = ctrl
+ self.op_count = -1
+ self.ctrl.addTextBlock(self.blk_item)
+ self.pairw = self.ctrl.pairwidget_list[self.blk_item.idx]
+ self.ctrl.txtblkShapeControl.setBlkItem(self.blk_item)
+
+ def redo(self):
+ if self.op_count < 0:
+ self.op_count += 1
+ self.blk_item.setSelected(True)
+ return
+ self.ctrl.recoverTextblkItemList([self.blk_item], [self.pairw])
+
+ def undo(self):
+ self.ctrl.deleteTextblkItemList([self.blk_item], [self.pairw])
+
+
+class EmptyCommand(QUndoCommand):
+ def __init__(self, parent=None):
+ super().__init__(parent=parent)
+
+
+class DeleteBlkItemsCommand(QUndoCommand):
+ def __init__(self, blk_list: List[TextBlkItem], mode: int, ctrl, parent=None):
+ super().__init__(parent)
+ self.op_counter = 0
+ self.blk_list = []
+ self.pwidget_list: List[TransPairWidget] = []
+ self.ctrl: SceneTextManager = ctrl
+ self.sw = self.ctrl.canvas.search_widget
+ self.canvas: Canvas = ctrl.canvas
+ self.mode = mode
+
+ self.undo_img_list = []
+ self.redo_img_list = []
+ self.inpaint_rect_lst = []
+ self.mask_pnts = []
+ img_array = self.canvas.imgtrans_proj.inpainted_array
+ mask_array = self.canvas.imgtrans_proj.mask_array
+ original_array = self.canvas.imgtrans_proj.img_array
+
+ self.search_rstedit_list: List[SourceTextEdit] = []
+ self.search_counter_list = []
+ self.highlighter_list = []
+ self.old_counter_sum = self.sw.counter_sum
+ self.sw_changed = False
+
+ blk_list.sort(key=lambda blk: blk.idx)
+
+ for blkitem in blk_list:
+ if not isinstance(blkitem, TextBlkItem):
+ continue
+ self.blk_list.append(blkitem)
+ pw: TransPairWidget = ctrl.pairwidget_list[blkitem.idx]
+ self.pwidget_list.append(pw)
+
+ if mode == 1:
+ is_empty = False
+ msk, xyxy = get_block_mask(blkitem.absBoundingRect(), mask_array, blkitem.rotation())
+ if msk is None:
+ is_empty = True
+ if is_empty:
+ self.undo_img_list.append(None)
+ self.redo_img_list.append(None)
+ self.inpaint_rect_lst.append(None)
+ self.mask_pnts.append(None)
+ else:
+ x1, y1, x2, y2 = xyxy
+ self.mask_pnts.append(np.where(msk))
+ self.undo_img_list.append(np.copy(img_array[y1: y2, x1: x2]))
+ self.redo_img_list.append(np.copy(original_array[y1: y2, x1: x2]))
+ self.inpaint_rect_lst.append([x1, y1, x2, y2])
+
+ rst_idx = self.sw.get_result_edit_index(pw.e_trans)
+ if rst_idx != -1:
+ self.sw_changed = True
+ highlighter = self.sw.highlighter_list.pop(rst_idx)
+ counter = self.sw.search_counter_list.pop(rst_idx)
+ self.sw.counter_sum -= counter
+ if self.sw.current_edit == pw.e_trans:
+ highlighter.set_current_span(-1, -1)
+ self.search_rstedit_list.append(self.sw.search_rstedit_list.pop(rst_idx))
+ self.search_counter_list.append(counter)
+ self.highlighter_list.append(highlighter)
+
+ rst_idx = self.sw.get_result_edit_index(pw.e_source)
+ if rst_idx != -1:
+ self.sw_changed = True
+ highlighter = self.sw.highlighter_list.pop(rst_idx)
+ counter = self.sw.search_counter_list.pop(rst_idx)
+ self.sw.counter_sum -= counter
+ if self.sw.current_edit == pw.e_trans:
+ highlighter.set_current_span(-1, -1)
+ self.search_rstedit_list.append(self.sw.search_rstedit_list.pop(rst_idx))
+ self.search_counter_list.append(counter)
+ self.highlighter_list.append(highlighter)
+
+ self.new_counter_sum = self.sw.counter_sum
+ if self.sw_changed:
+ if self.sw.counter_sum > 0:
+ idx = self.sw.get_result_edit_index(self.sw.current_edit)
+ if self.sw.current_cursor is not None and idx != -1:
+ self.sw.result_pos = self.sw.highlighter_list[idx].matched_map[self.sw.current_cursor.position()]
+ if idx > 0:
+ self.sw.result_pos += sum(self.sw.search_counter_list[: idx])
+ self.sw.updateCounterText()
+ else:
+ self.sw.setCurrentEditor(self.sw.search_rstedit_list[0])
+ else:
+ self.sw.setCurrentEditor(None)
+
+ self.ctrl.deleteTextblkItemList(self.blk_list, self.pwidget_list)
+
+ def redo(self):
+
+ if self.mode == 1:
+ self.canvas.saved_drawundo_step -= 1
+ img_array = self.canvas.imgtrans_proj.inpainted_array
+ mask_array = self.canvas.imgtrans_proj.mask_array
+ for mskpnt, inpaint_rect, redo_img in zip(self.mask_pnts, self.inpaint_rect_lst, self.redo_img_list):
+ if mskpnt == None:
+ continue
+ x1, y1, x2, y2 = inpaint_rect
+ img_array[y1: y2, x1: x2][mskpnt] = redo_img[mskpnt]
+ mask_array[y1: y2, x1: x2][mskpnt] = 0
+ self.canvas.updateLayers()
+
+ if self.op_counter == 0:
+ self.op_counter += 1
+ return
+
+ self.ctrl.deleteTextblkItemList(self.blk_list, self.pwidget_list)
+ if self.sw_changed:
+ self.sw.counter_sum = self.new_counter_sum
+ cursor_removed = False
+ for edit in self.search_rstedit_list:
+ idx = self.sw.get_result_edit_index(edit)
+ if idx != -1:
+ self.sw.search_rstedit_list.pop(idx)
+ self.sw.search_counter_list.pop(idx)
+ self.sw.highlighter_list.pop(idx)
+ if edit == self.sw.current_edit:
+ cursor_removed = True
+ if cursor_removed:
+ if self.sw.counter_sum > 0:
+ self.sw.setCurrentEditor(self.sw.search_rstedit_list[0])
+ else:
+ self.sw.setCurrentEditor(None)
+
+ def undo(self):
+
+ if self.mode == 1:
+ self.canvas.saved_drawundo_step += 1
+ img_array = self.canvas.imgtrans_proj.inpainted_array
+ mask_array = self.canvas.imgtrans_proj.mask_array
+ for mskpnt, inpaint_rect, undo_img in zip(self.mask_pnts, self.inpaint_rect_lst, self.undo_img_list):
+ if mskpnt == None:
+ continue
+ x1, y1, x2, y2 = inpaint_rect
+ img_array[y1: y2, x1: x2][mskpnt] = undo_img[mskpnt]
+ mask_array[y1: y2, x1: x2][mskpnt] = 255
+ self.canvas.updateLayers()
+
+ self.ctrl.recoverTextblkItemList(self.blk_list, self.pwidget_list)
+ if self.sw_changed:
+ self.sw.counter_sum = self.old_counter_sum
+ self.sw.search_rstedit_list += self.search_rstedit_list
+ self.sw.search_counter_list += self.search_counter_list
+ self.sw.highlighter_list += self.highlighter_list
+ self.sw.updateCounterText()
+
+
+class PasteBlkItemsCommand(QUndoCommand):
+ def __init__(self, blk_list: List[TextBlkItem], pwidget_list: List[TransPairWidget], ctrl, parent=None):
+ super().__init__(parent)
+ self.op_counter = 0
+ self.blk_list = blk_list
+ self.ctrl:SceneTextManager = ctrl
+ blk_list.sort(key=lambda blk: blk.idx)
+
+ self.ctrl.canvas.block_selection_signal = True
+ for blkitem in blk_list:
+ blkitem.setSelected(True)
+ self.ctrl.on_incanvas_selection_changed()
+ self.ctrl.canvas.block_selection_signal = False
+ self.pwidget_list = pwidget_list
+
+
+ def redo(self):
+ if self.op_counter == 0:
+ self.op_counter += 1
+ return
+ self.ctrl.recoverTextblkItemList(self.blk_list, self.pwidget_list)
+
+ def undo(self):
+ self.ctrl.deleteTextblkItemList(self.blk_list, self.pwidget_list)
+
+
+class PasteSrcItemsCommand(QUndoCommand):
+ def __init__(self, src_list: List[SourceTextEdit], paste_list: List[str]):
+ super().__init__()
+ self.src_list = src_list
+ self.paste_list = paste_list
+ self.ori_text_list = [src.toPlainText() for src in src_list]
+
+ def redo(self):
+ for src, text in zip(self.src_list, self.paste_list):
+ src.setPlainText(text)
+
+ def undo(self):
+ for src, text in zip(self.src_list, self.ori_text_list):
+ src.setPlainText(text)
+
+
+class RearrangeBlksCommand(QUndoCommand):
+
+ def __init__(self, rmap: Tuple, ctrl, parent=None):
+ super().__init__(parent)
+ self.ctrl: SceneTextManager = ctrl
+ self.src_ids, self.tgt_ids = rmap[0], rmap[1]
+
+ self.nr = len(self.src_ids)
+ self.src2tgt = {}
+ self.tgt2src = {}
+ for s, t in zip(self.src_ids, self.tgt_ids):
+ self.src2tgt[s] = t
+ self.tgt2src[t] = s
+ self.visible_ = None
+ self.redo_visible_idx = self.undo_visible_idx = None
+ if len(rmap) > 2:
+ self.redo_visible_idx, self.undo_visible_idx = rmap[2]
+
+ def redo(self):
+ self.rearange_blk_ids(self.src_ids, self.tgt_ids, self.redo_visible_idx)
+
+ def undo(self):
+ self.rearange_blk_ids(self.tgt_ids, self.src_ids, self.undo_visible_idx)
+
+ def rearange_blk_ids(self, src_ids, tgt_ids, visible_idx = None):
+ src_ids = np.array(src_ids)
+ tgt_ids = np.array(tgt_ids)
+ src_order_ids = np.argsort(src_ids)[::-1]
+
+ src_ids = src_ids[src_order_ids]
+ tgt_ids = tgt_ids[src_order_ids]
+
+ blks: List[TextBlkItem] = []
+ pws: List[TransPairWidget] = []
+ for pos, pos_tgt in zip(src_ids, tgt_ids):
+ pw = self.ctrl.pairwidget_list.pop(pos)
+ if visible_idx == pos_tgt:
+ pw.hide()
+ blk = self.ctrl.textblk_item_list.pop(pos)
+ pws.append(pw)
+ blks.append(blk)
+
+ tgt_order_ids = np.argsort(tgt_ids)
+ for ii in tgt_order_ids:
+ pos = tgt_ids[ii]
+ self.ctrl.textblk_item_list.insert(pos, blks[ii])
+
+ self.ctrl.textEditList.insertPairWidget(pws[ii], pos)
+ self.ctrl.pairwidget_list.insert(pos, pws[ii])
+
+ self.ctrl.updateTextBlkItemIdx(set(tgt_ids))
+ if visible_idx is not None:
+ pw_ct = self.ctrl.pairwidget_list[visible_idx]
+ pw_ct.show()
+ self.ctrl.textEditList.ensureWidgetVisible(pw_ct, yMargin=pw.height())
+
+
+class TextPanel(Widget):
+ def __init__(self, app: QApplication, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+ layout = QVBoxLayout(self)
+ self.textEditList = TextEditListScrollArea(self)
+ self.formatpanel = FontFormatPanel(app, self)
+ layout.addWidget(self.formatpanel)
+ layout.addWidget(self.textEditList)
+ layout.setContentsMargins(0, 0, 0, 0)
+ layout.setSpacing(7)
+ layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
+
+class SceneTextManager(QObject):
+ new_textblk = Signal(int)
+ def __init__(self,
+ app: QApplication,
+ mainwindow: QWidget,
+ canvas: Canvas,
+ textpanel: TextPanel,
+ *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+ self.app = app
+ self.mainwindow = mainwindow
+ self.canvas = canvas
+ canvas.switch_text_item.connect(self.on_switch_textitem)
+ self.selectext_minimenu: SelectTextMiniMenu = None
+ self.canvas.scalefactor_changed.connect(self.adjustSceneTextRect)
+ self.canvas.end_create_textblock.connect(self.onEndCreateTextBlock)
+ self.canvas.paste2selected_textitems.connect(self.on_paste2selected_textitems)
+ self.canvas.delete_textblks.connect(self.onDeleteBlkItems)
+ self.canvas.copy_textblks.connect(self.onCopyBlkItems)
+ self.canvas.paste_textblks.connect(self.onPasteBlkItems)
+ self.canvas.format_textblks.connect(self.onFormatTextblks)
+ self.canvas.layout_textblks.connect(self.onAutoLayoutTextblks)
+ self.canvas.reset_angle.connect(self.onResetAngle)
+ self.canvas.squeeze_blk.connect(self.onSqueezeBlk)
+ self.canvas.incanvas_selection_changed.connect(self.on_incanvas_selection_changed)
+ self.txtblkShapeControl = canvas.txtblkShapeControl
+ self.textpanel = textpanel
+ self.textEditList = textpanel.textEditList
+ self.textEditList.focus_out.connect(self.on_textedit_list_focusout)
+ self.textEditList.textpanel_contextmenu_requested.connect(canvas.on_create_contextmenu)
+ self.textEditList.selection_changed.connect(self.on_transwidget_selection_changed)
+ self.textEditList.rearrange_blks.connect(self.on_rearrange_blks)
+ self.formatpanel = textpanel.formatpanel
+ self.formatpanel.textstyle_panel.apply_fontfmt.connect(self.onFormatTextblks)
+
+ self.imgtrans_proj = self.canvas.imgtrans_proj
+ self.textblk_item_list: List[TextBlkItem] = []
+ self.pairwidget_list: List[TransPairWidget] = self.textEditList.pairwidget_list
+
+ self.auto_textlayout_flag = False
+ self.hovering_transwidget : TransTextEdit = None
+
+ self.prev_blkitem: TextBlkItem = None
+
+ def on_switch_textitem(self, switch_delta: int, key_event: QKeyEvent = None, current_editing_widget: Union[SourceTextEdit, TransTextEdit] = None):
+ n_blk = len(self.textblk_item_list)
+ if n_blk < 1:
+ return
+
+ editing_blk = None
+ if current_editing_widget is None:
+ editing_blk = self.editingTextItem()
+ if editing_blk is not None:
+ tgt_idx = editing_blk.idx + switch_delta
+ else:
+ sel_blks = self.canvas.selected_text_items(sort=False)
+ if len(sel_blks) == 0:
+ return
+ sel_blk = sel_blks[0]
+ tgt_idx = sel_blk.idx + switch_delta
+ else:
+ tgt_idx = current_editing_widget.idx + switch_delta
+
+ if tgt_idx < 0:
+ tgt_idx += n_blk
+ elif tgt_idx >= n_blk:
+ tgt_idx -= n_blk
+ blk = self.textblk_item_list[tgt_idx]
+
+ if current_editing_widget is None:
+ if editing_blk is None:
+ self.canvas.block_selection_signal = True
+ self.canvas.clearSelection()
+ blk.setSelected(True)
+ self.canvas.block_selection_signal = False
+ self.canvas.gv.ensureVisible(blk)
+ self.txtblkShapeControl.setBlkItem(blk)
+ edit = self.pairwidget_list[tgt_idx].e_trans
+ self.changeHoveringWidget(edit)
+ self.textEditList.set_selected_list([blk.idx])
+ else:
+ editing_blk.endEdit()
+ editing_blk.setSelected(False)
+ self.txtblkShapeControl.setBlkItem(blk)
+ blk.setSelected(True)
+ blk.startEdit()
+ self.canvas.gv.ensureVisible(blk)
+ else:
+ self.textblk_item_list[current_editing_widget.idx].setSelected(False)
+ current_pw = self.pairwidget_list[tgt_idx]
+ is_trans = isinstance(current_editing_widget, TransTextEdit)
+ if is_trans:
+ w = current_pw.e_trans
+ else:
+ w = current_pw.e_source
+
+ self.changeHoveringWidget(w)
+ w.setFocus()
+
+ if key_event is not None:
+ key_event.accept()
+
+ def setTextEditMode(self, edit: bool = False):
+ if edit:
+ self.textpanel.show()
+ self.canvas.textLayer.show()
+ else:
+ self.txtblkShapeControl.setBlkItem(None)
+ self.textpanel.hide()
+ self.textpanel.formatpanel.set_textblk_item()
+ self.canvas.textLayer.hide()
+
+ def adjustSceneTextRect(self):
+ self.txtblkShapeControl.updateBoundingRect()
+
+ def clearSceneTextitems(self):
+ self.hovering_transwidget = None
+ self.txtblkShapeControl.setBlkItem(None)
+ for blkitem in self.textblk_item_list:
+ self.canvas.removeItem(blkitem)
+ self.textblk_item_list.clear()
+ self.textEditList.clearAllSelected()
+ for textwidget in self.pairwidget_list:
+ self.textEditList.removeWidget(textwidget)
+ self.pairwidget_list.clear()
+
+ def updateSceneTextitems(self):
+ self.hovering_transwidget = None
+ self.txtblkShapeControl.setBlkItem(None)
+ self.clearSceneTextitems()
+ for textblock in self.imgtrans_proj.current_block_list():
+ if textblock.font_family is None or textblock.font_family.strip() == '':
+ textblock.font_family = self.formatpanel.familybox.currentText()
+ blk_item = self.addTextBlock(textblock)
+ if self.auto_textlayout_flag:
+ self.updateTextBlkList()
+
+ def addTextBlock(self, blk: Union[TextBlock, TextBlkItem] = None) -> TextBlkItem:
+ if isinstance(blk, TextBlkItem):
+ blk_item = blk
+ blk_item.idx = len(self.textblk_item_list)
+ else:
+ translation = ''
+ if self.auto_textlayout_flag and not blk.vertical:
+ translation = blk.translation
+ blk.translation = ''
+ blk_item = TextBlkItem(blk, len(self.textblk_item_list), show_rect=self.canvas.textblock_mode)
+ if translation:
+ blk.translation = translation
+ rst = self.layout_textblk(blk_item, text=translation)
+ if rst is None:
+ blk_item.setPlainText(translation)
+ self.addTextBlkItem(blk_item)
+
+ pair_widget = TransPairWidget(blk, len(self.pairwidget_list), pcfg.fold_textarea)
+ self.pairwidget_list.append(pair_widget)
+ self.textEditList.addPairWidget(pair_widget)
+ pair_widget.e_source.setPlainText(blk_item.blk.get_text())
+ pair_widget.e_source.focus_in.connect(self.on_transwidget_focus_in)
+ pair_widget.e_source.ensure_scene_visible.connect(self.on_ensure_textitem_svisible)
+ pair_widget.e_source.push_undo_stack.connect(self.on_push_edit_stack)
+ pair_widget.e_source.redo_signal.connect(self.on_textedit_redo)
+ pair_widget.e_source.undo_signal.connect(self.on_textedit_undo)
+ pair_widget.e_source.show_select_menu.connect(self.on_show_select_menu)
+ pair_widget.e_source.focus_out.connect(self.on_pairw_focusout)
+
+ pair_widget.e_trans.setPlainText(blk_item.toPlainText())
+ pair_widget.e_trans.focus_in.connect(self.on_transwidget_focus_in)
+ pair_widget.e_trans.propagate_user_edited.connect(self.on_propagate_transwidget_edit)
+ pair_widget.e_trans.ensure_scene_visible.connect(self.on_ensure_textitem_svisible)
+ pair_widget.e_trans.push_undo_stack.connect(self.on_push_edit_stack)
+ pair_widget.e_trans.redo_signal.connect(self.on_textedit_redo)
+ pair_widget.e_trans.undo_signal.connect(self.on_textedit_undo)
+ pair_widget.e_trans.show_select_menu.connect(self.on_show_select_menu)
+ pair_widget.e_trans.focus_out.connect(self.on_pairw_focusout)
+ pair_widget.drag_move.connect(self.textEditList.handle_drag_pos)
+ pair_widget.pw_drop.connect(self.textEditList.on_pw_dropped)
+ pair_widget.idx_edited.connect(self.textEditList.on_idx_edited)
+
+ self.new_textblk.emit(blk_item.idx)
+ return blk_item
+
+ def addTextBlkItem(self, textblk_item: TextBlkItem) -> TextBlkItem:
+ self.textblk_item_list.append(textblk_item)
+ textblk_item.setParentItem(self.canvas.textLayer)
+ textblk_item.begin_edit.connect(self.onTextBlkItemBeginEdit)
+ textblk_item.end_edit.connect(self.onTextBlkItemEndEdit)
+ textblk_item.hover_enter.connect(self.onTextBlkItemHoverEnter)
+ textblk_item.leftbutton_pressed.connect(self.onLeftbuttonPressed)
+ textblk_item.moving.connect(self.onTextBlkItemMoving)
+ textblk_item.moved.connect(self.onTextBlkItemMoved)
+ textblk_item.reshaped.connect(self.onTextBlkItemReshaped)
+ textblk_item.rotated.connect(self.onTextBlkItemRotated)
+ textblk_item.push_undo_stack.connect(self.on_push_textitem_undostack)
+ textblk_item.undo_signal.connect(self.on_textedit_undo)
+ textblk_item.redo_signal.connect(self.on_textedit_redo)
+ textblk_item.propagate_user_edited.connect(self.on_propagate_textitem_edit)
+ textblk_item.doc_size_changed.connect(self.onTextBlkItemSizeChanged)
+ textblk_item.pasted.connect(self.onBlkitemPaste)
+ return textblk_item
+
+ def deleteTextblkItemList(self, blkitem_list: List[TextBlkItem], p_widget_list: List[TransPairWidget]):
+ selection_changed = False
+ for blkitem, p_widget in zip(blkitem_list, p_widget_list):
+ if blkitem.isSelected():
+ selection_changed = True
+ self.canvas.removeItem(blkitem) # removeItem itself will block incanvas_selection_changed
+ self.textblk_item_list.remove(blkitem)
+ self.pairwidget_list.remove(p_widget)
+ self.textEditList.removeWidget(p_widget)
+ self.updateTextBlkItemIdx()
+ self.txtblkShapeControl.setBlkItem(None)
+ if selection_changed:
+ # it must be called after updateTextBlkItemIdx if blk.idx changed
+ self.on_incanvas_selection_changed()
+
+ def recoverTextblkItemList(self, blkitem_list: List[TextBlkItem], p_widget_list: List[TransPairWidget]):
+ self.canvas.block_selection_signal = True
+ for blkitem, p_widget in zip(blkitem_list, p_widget_list):
+ self.textblk_item_list.insert(blkitem.idx, blkitem)
+ blkitem.setParentItem(self.canvas.textLayer)
+ self.pairwidget_list.insert(p_widget.idx, p_widget)
+ self.textEditList.insertPairWidget(p_widget, p_widget.idx)
+ if self.txtblkShapeControl.blk_item is not None and blkitem.isSelected():
+ blkitem.setSelected(False)
+ self.updateTextBlkItemIdx()
+ self.on_incanvas_selection_changed()
+ self.canvas.block_selection_signal = False
+
+ def onTextBlkItemSizeChanged(self, idx: int):
+ blk_item = self.textblk_item_list[idx]
+ if not self.txtblkShapeControl.reshaping:
+ if self.txtblkShapeControl.blk_item == blk_item:
+ self.txtblkShapeControl.updateBoundingRect()
+
+ @property
+ def app_clipborad(self) -> QClipboard:
+ return self.app.clipboard()
+
+ def onBlkitemPaste(self, idx: int):
+ blk_item = self.textblk_item_list[idx]
+ text = self.app_clipborad.text()
+ cursor = blk_item.textCursor()
+ cursor.insertText(text)
+
+ def onTextBlkItemBeginEdit(self, blk_id: int):
+ blk_item = self.textblk_item_list[blk_id]
+ self.txtblkShapeControl.setBlkItem(blk_item)
+ self.canvas.editing_textblkitem = blk_item
+ self.formatpanel.set_textblk_item(blk_item)
+ self.txtblkShapeControl.startEditing()
+ e_trans = self.pairwidget_list[blk_item.idx].e_trans
+ self.changeHoveringWidget(e_trans)
+
+ def changeHoveringWidget(self, edit: SourceTextEdit):
+ if self.hovering_transwidget is not None and self.hovering_transwidget != edit:
+ self.hovering_transwidget.setHoverEffect(False)
+ self.hovering_transwidget = edit
+ if edit is not None:
+ pw = self.pairwidget_list[edit.idx]
+ h = pw.height()
+ if shared.USE_PYSIDE6:
+ self.textEditList.ensureWidgetVisible(pw, ymargin=h)
+ else:
+ self.textEditList.ensureWidgetVisible(pw, yMargin=h)
+ edit.setHoverEffect(True)
+
+ def onLeftbuttonPressed(self, blk_id: int):
+ blk_item = self.textblk_item_list[blk_id]
+ self.txtblkShapeControl.setBlkItem(blk_item)
+ selections: List[TextBlkItem] = self.canvas.selectedItems()
+ if len(selections) > 1:
+ for item in selections:
+ item.oldPos = item.pos()
+ self.changeHoveringWidget(self.pairwidget_list[blk_id].e_trans)
+
+ def onTextBlkItemEndEdit(self, blk_id: int):
+ self.canvas.editing_textblkitem = None
+ self.textblk_item_list[blk_id].setSelected(True)
+ self.txtblkShapeControl.endEditing()
+
+ def editingTextItem(self) -> TextBlkItem:
+ if self.txtblkShapeControl.isVisible() and self.canvas.editing_textblkitem is not None:
+ return self.canvas.editing_textblkitem
+ return None
+
+ def savePrevBlkItem(self, blkitem: TextBlkItem):
+ self.prev_blkitem = blkitem
+ self.prev_textCursor = QTextCursor(self.prev_blkitem.textCursor())
+
+ def is_editting(self):
+ blk_item = self.txtblkShapeControl.blk_item
+ return blk_item is not None and blk_item.is_editting()
+
+ def onTextBlkItemHoverEnter(self, blk_id: int):
+ if self.is_editting():
+ return
+ blk_item = self.textblk_item_list[blk_id]
+ if not blk_item.hasFocus():
+ self.txtblkShapeControl.setBlkItem(blk_item)
+
+ def onTextBlkItemMoving(self, item: TextBlkItem):
+ self.txtblkShapeControl.updateBoundingRect()
+
+ def onTextBlkItemMoved(self):
+ selected_blks = self.canvas.selected_text_items()
+ if len(selected_blks) > 0:
+ self.canvas.push_undo_command(MoveBlkItemsCommand(selected_blks, self.txtblkShapeControl))
+
+ def onTextBlkItemReshaped(self, item: TextBlkItem):
+ self.canvas.push_undo_command(ReshapeItemCommand(item))
+
+ def onTextBlkItemRotated(self, new_angle: float):
+ blk_item = self.txtblkShapeControl.blk_item
+ if blk_item:
+ self.canvas.push_undo_command(RotateItemCommand(blk_item, new_angle, self.txtblkShapeControl))
+
+ def onDeleteBlkItems(self, mode: int):
+ selected_blks = self.canvas.selected_text_items()
+ if len(selected_blks) == 0 and self.txtblkShapeControl.blk_item is not None:
+ selected_blks.append(self.txtblkShapeControl.blk_item)
+ if len(selected_blks) > 0:
+ self.canvas.push_undo_command(DeleteBlkItemsCommand(selected_blks, mode, self))
+
+ def onCopyBlkItems(self):
+ selected_blks = self.canvas.selected_text_items()
+ if len(selected_blks) == 0 and self.txtblkShapeControl.blk_item is not None:
+ selected_blks.append(self.txtblkShapeControl.blk_item)
+
+ if len(selected_blks) == 0:
+ return
+
+ self.canvas.clipboard_blks.clear()
+ if self.canvas.text_change_unsaved():
+ self.updateTextBlkList()
+
+ pos = selected_blks[0].blk.bounding_rect()
+ pos_x = int(pos[0] + pos[2] / 2)
+ pos_y = int(pos[1] + pos[3] / 2)
+
+ textlist = []
+ for blkitem in selected_blks:
+ blk = copy.deepcopy(blkitem.blk)
+ blk.adjust_pos(-pos_x, -pos_y)
+ self.canvas.clipboard_blks.append(blk)
+ textlist.append(blkitem.toPlainText().strip())
+ textlist = '\n'.join(textlist)
+ self.app_clipborad.setText(textlist, QClipboard.Mode.Clipboard)
+
+
+ def onPasteBlkItems(self, pos: QPointF):
+ if pos is None:
+ pos_x, pos_y = 0, 0
+ else:
+ pos_x, pos_y = pos.x(), pos.y()
+ pos_x = int(pos_x / self.canvas.scale_factor)
+ pos_y = int(pos_y / self.canvas.scale_factor)
+ blkitem_list, pair_widget_list = [], []
+ for blk in self.canvas.clipboard_blks:
+ blk = copy.deepcopy(blk)
+ blk.adjust_pos(pos_x, pos_y)
+ blkitem = self.addTextBlock(blk)
+ pairw = self.pairwidget_list[-1]
+ blkitem_list.append(blkitem)
+ pair_widget_list.append(pairw)
+ if len(blkitem_list) > 0:
+ self.canvas.clearSelection()
+ self.canvas.push_undo_command(PasteBlkItemsCommand(blkitem_list, pair_widget_list, self))
+ if len(blkitem_list) == 1:
+ self.formatpanel.set_textblk_item(blkitem_list[0])
+ else:
+ self.formatpanel.set_textblk_item(multi_select=True)
+
+ def onFormatTextblks(self, fmt: FontFormat = None):
+ if fmt is None:
+ fmt = self.formatpanel.global_format
+ self.apply_fontformat(fmt)
+
+ def onAutoLayoutTextblks(self):
+ selected_blks = self.canvas.selected_text_items()
+ old_html_lst, old_rect_lst, trans_widget_lst = [], [], []
+ selected_blks = [blk for blk in selected_blks if not blk.fontformat.vertical]
+ if len(selected_blks) > 0:
+ for blkitem in selected_blks:
+ old_html_lst.append(blkitem.toHtml())
+ old_rect_lst.append(blkitem.absBoundingRect(qrect=True))
+ trans_widget_lst.append(self.pairwidget_list[blkitem.idx].e_trans)
+ self.layout_textblk(blkitem)
+
+ self.canvas.push_undo_command(AutoLayoutCommand(selected_blks, old_rect_lst, old_html_lst, trans_widget_lst))
+
+ def onResetAngle(self):
+ selected_blks = self.canvas.selected_text_items()
+ if len(selected_blks) > 0:
+ self.canvas.push_undo_command(ResetAngleCommand(selected_blks, self.txtblkShapeControl))
+
+ def onSqueezeBlk(self):
+ selected_blks = self.canvas.selected_text_items()
+ if len(selected_blks) > 0:
+ self.canvas.push_undo_command(SqueezeCommand(selected_blks, self.txtblkShapeControl))
+
+ def on_incanvas_selection_changed(self):
+ if self.canvas.textEditMode():
+ textitems = self.canvas.selected_text_items()
+ self.textEditList.set_selected_list([t.idx for t in textitems])
+ if len(textitems) == 1:
+ self.formatpanel.set_textblk_item(textitems[-1])
+ else:
+ self.formatpanel.set_textblk_item(multi_select=bool(textitems))
+
+ def layout_textblk(self, blkitem: TextBlkItem, text: str = None, mask: np.ndarray = None, bounding_rect: List = None, region_rect: List = None):
+
+ '''
+ auto text layout, vertical writing is not supported yet.
+ '''
+
+ img = self.imgtrans_proj.img_array
+ if img is None:
+ return
+
+ src_is_cjk = is_cjk(pcfg.module.translate_source)
+ tgt_is_cjk = is_cjk(pcfg.module.translate_target)
+
+ # disable for vertical writing
+ if blkitem.blk.vertical:
+ return
+
+ old_br = blkitem.absBoundingRect(qrect=True)
+ old_br = [old_br.x(), old_br.y(), old_br.width(), old_br.height()]
+ if old_br[2] < 1:
+ return
+
+ blk_font = blkitem.font()
+ fmt = blkitem.get_fontformat()
+ blk_font.setLetterSpacing(QFont.SpacingType.PercentageSpacing, fmt.letter_spacing * 100)
+ text_size_func = lambda text: get_text_size(QFontMetricsF(blk_font), text)
+
+ restore_charfmts = False
+ if text is None:
+ text = blkitem.toPlainText()
+ restore_charfmts = True
+
+ if not text.strip():
+ return
+
+ if mask is None:
+ im_h, im_w = img.shape[:2]
+ bounding_rect = blkitem.absBoundingRect(max_h=im_h, max_w=im_w)
+ if bounding_rect[2] <= 0 or bounding_rect[3] <= 0:
+ blkitem.setPlainText(text)
+ if len(self.pairwidget_list) > blkitem.idx:
+ self.pairwidget_list[blkitem.idx].e_trans.setPlainText(text)
+ return
+ if tgt_is_cjk:
+ max_enlarge_ratio = 2.5
+ else:
+ max_enlarge_ratio = 3
+ enlarge_ratio = min(max(bounding_rect[2] / bounding_rect[3], bounding_rect[3] / bounding_rect[2]) * 1.5, max_enlarge_ratio)
+ mask, ballon_area, mask_xyxy, region_rect = extract_ballon_region(img, bounding_rect, enlarge_ratio=enlarge_ratio, cal_region_rect=True)
+ else:
+ mask_xyxy = [bounding_rect[0], bounding_rect[1], bounding_rect[0]+bounding_rect[2], bounding_rect[1]+bounding_rect[3]]
+
+ words, delimiter = seg_text(text, pcfg.module.translate_target)
+ if len(words) < 1:
+ return
+
+ wl_list = get_words_length_list(QFontMetricsF(blk_font), words)
+ text_w, text_h = text_size_func(text)
+ text_area = text_w * text_h
+ if tgt_is_cjk:
+ line_height = int(round(fmt.line_spacing * text_size_func('X木')[1]))
+ else:
+ line_height = int(round(fmt.line_spacing * text_size_func('X')[1]))
+ delimiter_len = text_size_func(delimiter)[0]
+
+ ref_src_lines = False
+ if not blkitem.blk.src_is_vertical:
+ ref_src_lines = blkitem.blk.line_coord_valid(old_br)
+
+ adaptive_fntsize = False
+ resize_ratio = 1
+ if self.auto_textlayout_flag and pcfg.let_fntsize_flag == 0 and pcfg.let_autolayout_flag:
+ if blkitem.blk.src_is_vertical and blkitem.blk.vertical != blkitem.blk.src_is_vertical:
+ adaptive_fntsize = True
+ area_ratio = ballon_area / text_area
+ ballon_area_thresh = 1.7
+ downscale_constraint = 0.6
+ resize_ratio = np.clip(min(area_ratio / ballon_area_thresh, region_rect [2] / max(wl_list)), downscale_constraint, 1.0)
+
+ else:
+ if not src_is_cjk:
+ resize_ratio_ballon = max(ballon_area / 1.2 / text_area, 0.7)
+ if ref_src_lines:
+ _, src_width = blkitem.blk.normalizd_width_list(normalize=False)
+ resize_ratio_src = src_width / (sum(wl_list) + max((len(wl_list) - 1 - len(blkitem.blk.lines_array())), 0) * delimiter_len)
+ resize_ratio = min(resize_ratio_ballon, resize_ratio_src)
+ else:
+ resize_ratio = resize_ratio_ballon
+ elif not blkitem.blk.src_is_vertical and ref_src_lines:
+ _, src_width = blkitem.blk.normalizd_width_list(normalize=False)
+ resize_ratio_src = src_width / (sum(wl_list) + max((len(wl_list) - 1 - len(blkitem.blk.lines_array())), 0) * delimiter_len)
+ resize_ratio = max(resize_ratio_src * 1.5, 0.5)
+ resize_ratio = min(max(resize_ratio, 0.6), 1)
+
+ if resize_ratio != 1:
+ new_font_size = blk_font.pointSizeF() * resize_ratio
+ blk_font.setPointSizeF(new_font_size)
+ wl_list = (np.array(wl_list, np.float64) * resize_ratio).astype(np.int32).tolist()
+ line_height = int(line_height * resize_ratio)
+ text_w = int(text_w * resize_ratio)
+ delimiter_len = int(delimiter_len * resize_ratio)
+
+ max_central_width = np.inf
+ if fmt.alignment == 1:
+ if len(blkitem.blk) > 0:
+ centroid = blkitem.blk.center().astype(np.int64).tolist()
+ centroid[0] -= mask_xyxy[0]
+ centroid[1] -= mask_xyxy[1]
+ else:
+ centroid = [bounding_rect[2] // 2, bounding_rect[3] // 2]
+ else:
+ max_central_width = np.inf
+ centroid = [0, 0]
+ abs_centroid = [bounding_rect[0], bounding_rect[1]]
+ if len(blkitem.blk) > 0:
+ blkitem.blk.lines[0]
+ abs_centroid = blkitem.blk.lines[0][0]
+ centroid[0] = int(abs_centroid[0] - mask_xyxy[0])
+ centroid[1] = int(abs_centroid[1] - mask_xyxy[1])
+
+ new_text, xywh, start_from_top, adjust_xy = layout_text(
+ blkitem.blk,
+ mask,
+ mask_xyxy,
+ centroid,
+ words,
+ wl_list,
+ delimiter,
+ delimiter_len,
+ line_height,
+ 0,
+ max_central_width,
+ src_is_cjk=src_is_cjk,
+ tgt_is_cjk=tgt_is_cjk,
+ ref_src_lines=ref_src_lines
+ )
+
+ # font size post adjustment
+ post_resize_ratio = 1
+ if adaptive_fntsize:
+ downscale_constraint = 0.5
+ w = xywh[2]
+ post_resize_ratio = np.clip(max(region_rect[2] / w, downscale_constraint), 0, 1)
+ resize_ratio *= post_resize_ratio
+
+ if post_resize_ratio != 1:
+ cx, cy = xywh[0] + xywh[2] / 2, xywh[1] + xywh[3] / 2
+ w, h = xywh[2] * post_resize_ratio, xywh[3] * post_resize_ratio
+ xywh = [int(cx - w / 2), int(cy - h / 2), int(w), int(h)]
+
+ if resize_ratio != 1:
+ new_font_size = blkitem.font().pointSizeF() * resize_ratio
+ blkitem.textCursor().clearSelection()
+ blkitem.setFontSize(new_font_size)
+ blk_font.setPointSizeF(new_font_size)
+
+ if restore_charfmts:
+ char_fmts = blkitem.get_char_fmts()
+
+ ffmt = QFontMetricsF(blk_font)
+ maxw = max([ffmt.horizontalAdvance(t) for t in new_text.split('\n')])
+ blkitem.set_size(maxw * 1.5, xywh[3], set_layout_maxsize=True)
+ blkitem.setPlainText(new_text)
+ if len(self.pairwidget_list) > blkitem.idx:
+ self.pairwidget_list[blkitem.idx].e_trans.setPlainText(new_text)
+ if restore_charfmts:
+ self.restore_charfmts(blkitem, text, new_text, char_fmts)
+ blkitem.squeezeBoundingRect()
+ return True
+
+ def restore_charfmts(self, blkitem: TextBlkItem, text: str, new_text: str, char_fmts: List[QTextCharFormat]):
+ cursor = blkitem.textCursor()
+ cpos = 0
+ num_text = len(new_text)
+ num_fmt = len(char_fmts)
+ blkitem.layout.relayout_on_changed = False
+ blkitem.repaint_on_changed = False
+ if num_text >= num_fmt:
+ for fmt_i in range(num_fmt):
+ fmt = char_fmts[fmt_i]
+ ori_char = text[fmt_i].strip()
+ if ori_char == '':
+ continue
+ else:
+ if cursor.atEnd():
+ break
+ matched = False
+ while cpos < num_text:
+ if new_text[cpos] == ori_char:
+ matched = True
+ break
+ cpos += 1
+ if matched:
+ cursor.clearSelection()
+ cursor.setPosition(cpos)
+ cursor.setPosition(cpos+1, QTextCursor.MoveMode.KeepAnchor)
+ cursor.setCharFormat(fmt)
+ cursor.setBlockCharFormat(fmt)
+ cpos += 1
+ blkitem.repaint_on_changed = True
+ blkitem.layout.relayout_on_changed = True
+ blkitem.layout.reLayout()
+ blkitem.repaint_background()
+
+ def onEndCreateTextBlock(self, rect: QRectF):
+ xyxy = np.array([rect.x(), rect.y(), rect.right(), rect.bottom()])
+ xyxy = np.round(xyxy).astype(np.int32)
+ block = TextBlock(xyxy)
+ xywh = np.copy(xyxy)
+ xywh[[2, 3]] -= xywh[[0, 1]]
+ block.set_lines_by_xywh(xywh)
+ block.src_is_vertical = self.formatpanel.global_format.vertical
+ blk_item = TextBlkItem(block, len(self.textblk_item_list), set_format=False, show_rect=True)
+ blk_item.set_fontformat(self.formatpanel.global_format)
+ self.canvas.push_undo_command(CreateItemCommand(blk_item, self))
+
+ def on_paste2selected_textitems(self):
+ blkitems = self.canvas.selected_text_items()
+ text = self.app_clipborad.text()
+
+ num_blk = len(blkitems)
+ if num_blk < 1:
+ return
+
+ if num_blk > 1:
+ text_list = text.rstrip().split('\n')
+ num_text = len(text_list)
+ if num_text > 1:
+ if num_text > num_blk:
+ text_list = text_list[:num_blk]
+ elif num_text < num_blk:
+ text_list = text_list + [text_list[-1]] * (num_blk - num_text)
+ text = text_list
+
+ etrans = [self.pairwidget_list[blkitem.idx].e_trans for blkitem in blkitems]
+ self.canvas.push_undo_command(MultiPasteCommand(text, blkitems, etrans))
+
+ def onRotateTextBlkItem(self, item: TextBlock):
+ self.canvas.push_undo_command(RotateItemCommand(item))
+
+ def on_transwidget_focus_in(self, idx: int):
+ if self.is_editting():
+ textitm = self.editingTextItem()
+ textitm.endEdit()
+ self.pairwidget_list[textitm.idx].e_trans.setHoverEffect(False)
+ self.textEditList.clearAllSelected()
+
+ if idx < len(self.textblk_item_list):
+ blk_item = self.textblk_item_list[idx]
+ sender = self.sender()
+ if isinstance(sender, TransTextEdit):
+ blk_item.setCacheMode(QGraphicsItem.CacheMode.NoCache)
+ self.canvas.gv.ensureVisible(blk_item)
+ self.txtblkShapeControl.setBlkItem(blk_item)
+
+ def on_textedit_redo(self):
+ self.canvas.redo_textedit()
+
+ def on_textedit_undo(self):
+ self.canvas.undo_textedit()
+
+ def on_show_select_menu(self, pos: QPoint, selected_text: str):
+ if pcfg.textselect_mini_menu:
+ if not selected_text:
+ if self.selectext_minimenu.isVisible():
+ self.selectext_minimenu.hide()
+ else:
+ self.selectext_minimenu.show()
+ self.selectext_minimenu.move(self.mainwindow.mapFromGlobal(pos))
+ self.selectext_minimenu.selected_text = selected_text
+
+ def on_block_current_editor(self, block: bool):
+ w: SourceTextEdit = self.app.focusWidget()
+ if isinstance(w, SourceTextEdit) or isinstance(w, TextBlkItem):
+ w.block_all_input = block
+
+ def on_pairw_focusout(self, idx: int):
+ if self.selectext_minimenu.isVisible():
+ self.selectext_minimenu.hide()
+ sender = self.sender()
+ if isinstance(sender, TransTextEdit) and idx < len(self.textblk_item_list):
+ blk_item = self.textblk_item_list[idx]
+ blk_item.setCacheMode(QGraphicsItem.CacheMode.DeviceCoordinateCache)
+
+ def on_push_textitem_undostack(self, num_steps: int, is_formatting: bool):
+ blkitem: TextBlkItem = self.sender()
+ e_trans = self.pairwidget_list[blkitem.idx].e_trans if not is_formatting else None
+ self.canvas.push_undo_command(TextItemEditCommand(blkitem, e_trans, num_steps, self.textpanel.formatpanel), update_pushed_step=is_formatting)
+
+ def on_push_edit_stack(self, num_steps: int):
+ edit: Union[TransTextEdit, SourceTextEdit] = self.sender()
+ is_trans = type(edit) == TransTextEdit
+ blkitem = self.textblk_item_list[edit.idx] if is_trans else None
+ self.canvas.push_undo_command(TextEditCommand(edit, num_steps, blkitem), update_pushed_step=not is_trans)
+
+ def on_propagate_textitem_edit(self, pos: int, added_text: str, joint_previous: bool):
+ blk_item: TextBlkItem = self.sender()
+ edit = self.pairwidget_list[blk_item.idx].e_trans
+ propagate_user_edit(blk_item, edit, pos, added_text, joint_previous)
+ self.canvas.push_text_command(command=None, update_pushed_step=True)
+
+ def on_propagate_transwidget_edit(self, pos: int, added_text: str, joint_previous: bool):
+ edit: TransTextEdit = self.sender()
+ blk_item = self.textblk_item_list[edit.idx]
+ if blk_item.isEditing():
+ blk_item.setTextInteractionFlags(Qt.TextInteractionFlag.NoTextInteraction)
+ propagate_user_edit(edit, blk_item, pos, added_text, joint_previous)
+ self.canvas.push_text_command(command=None, update_pushed_step=True)
+
+ def apply_fontformat(self, fontformat: FontFormat):
+ selected_blks = self.canvas.selected_text_items()
+ trans_widget_list = []
+ for blk in selected_blks:
+ trans_widget_list.append(self.pairwidget_list[blk.idx].e_trans)
+ if len(selected_blks) > 0:
+ self.canvas.push_undo_command(ApplyFontformatCommand(selected_blks, trans_widget_list, fontformat))
+ if self.formatpanel.global_mode():
+ if id(self.formatpanel.active_text_style_format()) != id(fontformat):
+ self.formatpanel.deactivate_style_label()
+ self.formatpanel.on_active_textstyle_label_changed()
+ else:
+ self.formatpanel.set_active_format(fontformat)
+
+ def on_transwidget_selection_changed(self):
+ selitems = self.canvas.selected_text_items()
+ selset = {pw.idx: pw for pw in self.textEditList.checked_list}
+ self.canvas.block_selection_signal = True
+ for blkitem in selitems:
+ if blkitem.idx not in selset:
+ blkitem.setSelected(False)
+ else:
+ selset.pop(blkitem.idx)
+ for idx in selset:
+ self.textblk_item_list[idx].setSelected(True)
+ self.canvas.block_selection_signal = False
+
+ def on_textedit_list_focusout(self):
+ fw = self.app.focusWidget()
+ focusing_edit = isinstance(fw, (SourceTextEdit, TransTextEdit))
+ if fw == self.canvas.gv or focusing_edit:
+ self.textEditList.clearDrag()
+ if focusing_edit:
+ self.textEditList.clearAllSelected()
+
+ def on_rearrange_blks(self, mv_map: Tuple[np.ndarray]):
+ self.canvas.push_undo_command(RearrangeBlksCommand(mv_map, self))
+
+ def updateTextBlkItemIdx(self, sel_ids: set = None):
+ for ii, blk_item in enumerate(self.textblk_item_list):
+ if sel_ids is not None and ii not in sel_ids:
+ continue
+ blk_item.idx = ii
+ self.pairwidget_list[ii].updateIndex(ii)
+ cl = self.textEditList.checked_list
+ if len(cl) != 0:
+ cl.sort(key=lambda x: x.idx)
+
+ def updateTextBlkList(self):
+ cbl = self.imgtrans_proj.current_block_list()
+ if cbl is None:
+ return
+ cbl.clear()
+ for blk_item, trans_pair in zip(self.textblk_item_list, self.pairwidget_list):
+ if not blk_item.document().isEmpty():
+ blk_item.blk.rich_text = blk_item.toHtml()
+ blk_item.blk.translation = blk_item.toPlainText()
+ else:
+ blk_item.blk.rich_text = ''
+ blk_item.blk.translation = ''
+ blk_item.blk.text = [trans_pair.e_source.toPlainText()]
+ blk_item.blk._bounding_rect = blk_item.absBoundingRect()
+ blk_item.updateBlkFormat()
+ cbl.append(blk_item.blk)
+
+ def updateTranslation(self):
+ for blk_item, transwidget in zip(self.textblk_item_list, self.pairwidget_list):
+ transwidget.e_trans.setPlainText(blk_item.blk.translation)
+ blk_item.setPlainText(blk_item.blk.translation)
+ self.canvas.clear_text_stack()
+
+ def showTextblkItemRect(self, draw_rect: bool):
+ for blk_item in self.textblk_item_list:
+ blk_item.draw_rect = draw_rect
+ blk_item.update()
+
+ def set_blkitems_selection(self, selected: bool, blk_items: List[TextBlkItem] = None):
+ self.canvas.block_selection_signal = True
+ if blk_items is None:
+ blk_items = self.textblk_item_list
+ for blk_item in blk_items:
+ blk_item.setSelected(selected)
+ self.canvas.block_selection_signal = False
+ self.on_incanvas_selection_changed()
+
+ def on_ensure_textitem_svisible(self):
+ edit: Union[TransTextEdit, SourceTextEdit] = self.sender()
+ self.changeHoveringWidget(edit)
+ self.canvas.gv.ensureVisible(self.textblk_item_list[edit.idx])
+ self.txtblkShapeControl.setBlkItem(self.textblk_item_list[edit.idx])
+
+ def on_page_replace_one(self):
+ self.canvas.push_undo_command(PageReplaceOneCommand(self.canvas.search_widget))
+
+ def on_page_replace_all(self):
+ self.canvas.push_undo_command(PageReplaceAllCommand(self.canvas.search_widget))
+
+def get_text_size(fm: QFontMetricsF, text: str) -> Tuple[int, int]:
+ brt = fm.tightBoundingRect(text)
+ br = fm.boundingRect(text)
+ return int(np.ceil(fm.horizontalAdvance(text))), int(np.ceil(brt.height()))
+
+def get_words_length_list(fm: QFontMetricsF, words: List[str]) -> List[int]:
+ return [int(np.ceil(fm.horizontalAdvance(word))) for word in words]
+
diff --git a/ui/shared_widget.py b/ui/shared_widget.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8502a52c028060258896641ccb7e0c7e8690c14
--- /dev/null
+++ b/ui/shared_widget.py
@@ -0,0 +1,4 @@
+from .canvas import Canvas
+
+canvas: Canvas = None
+st_manager = None
\ No newline at end of file
diff --git a/ui/text_advanced_format.py b/ui/text_advanced_format.py
new file mode 100644
index 0000000000000000000000000000000000000000..a92c8a7812100ff6e51cac444a2a143e3289aea4
--- /dev/null
+++ b/ui/text_advanced_format.py
@@ -0,0 +1,214 @@
+from typing import Any, Callable
+
+from qtpy.QtWidgets import QSizePolicy, QVBoxLayout, QPushButton, QGroupBox, QLabel, QHBoxLayout
+from qtpy.QtCore import Signal, Qt
+
+from .custom_widget import SmallColorPickerLabel, SmallParamLabel, PanelArea, SmallSizeControlLabel, SmallSizeComboBox, SmallParamLabel, SmallSizeComboBox, SmallComboBox, TextCheckerLabel
+from utils.fontformat import FontFormat
+
+
+class TextShadowGroup(QGroupBox):
+ def __init__(self, on_param_changed: Callable = None, title=None):
+ super().__init__(title=title)
+ self.on_param_changed = on_param_changed
+
+ self.xoffset_box = SmallSizeComboBox([-2, 2], 'shadow_xoffset', self)
+ self.xoffset_box.setToolTip(self.tr("Set X offset"))
+ self.xoffset_box.param_changed.connect(self.on_offset_changed)
+ self.xoffset_label = SmallSizeControlLabel(self, direction=1, text='X', alignment=Qt.AlignmentFlag.AlignCenter)
+ self.xoffset_label.size_ctrl_changed.connect(self.xoffset_box.changeByDelta)
+ self.xoffset_label.btn_released.connect(self.on_offset_changed)
+ xoffset_layout = QHBoxLayout()
+ xoffset_layout.addWidget(self.xoffset_label)
+ xoffset_layout.addWidget(self.xoffset_box)
+
+ self.yoffset_box = SmallSizeComboBox([-2, 2], 'shadow_yoffset', self)
+ self.yoffset_box.setToolTip(self.tr("Set Y offset"))
+ self.yoffset_box.param_changed.connect(self.on_offset_changed)
+ self.yoffset_label = SmallSizeControlLabel(self, direction=1, text='Y', alignment=Qt.AlignmentFlag.AlignCenter)
+ self.yoffset_label.size_ctrl_changed.connect(self.yoffset_box.changeByDelta)
+ self.yoffset_label.btn_released.connect(self.on_offset_changed)
+ yoffset_layout = QHBoxLayout()
+ yoffset_layout.addWidget(self.yoffset_label)
+ yoffset_layout.addWidget(self.yoffset_box)
+
+ self.color_label = SmallColorPickerLabel(self, param_name='shadow_color')
+
+ self.strength_box = SmallSizeComboBox([0, 3], 'shadow_strength', self)
+ self.strength_box.setToolTip(self.tr("Set Shadow Strength"))
+ self.strength_box.param_changed.connect(self.on_param_changed)
+ self.strength_label = SmallSizeControlLabel(self, direction=1, text=self.tr('Strength'), alignment=Qt.AlignmentFlag.AlignCenter)
+ self.strength_label.size_ctrl_changed.connect(lambda x : self.strength_box.changeByDelta(x, multiplier=0.03))
+ self.strength_label.btn_released.connect(lambda : self.on_param_changed('shadow_strength', self.strength_box.value()))
+ strength_layout = QHBoxLayout()
+ strength_layout.addWidget(self.strength_label)
+ strength_layout.addWidget(self.strength_box)
+
+ self.radius_box = SmallSizeComboBox([0, 2], 'shadow_radius', self)
+ self.radius_box.setToolTip(self.tr("Set Shadow Radius"))
+ self.radius_box.param_changed.connect(self.on_param_changed)
+ self.radius_label = SmallSizeControlLabel(self, direction=1, text=self.tr('Radius'), alignment=Qt.AlignmentFlag.AlignCenter)
+ self.radius_label.size_ctrl_changed.connect(self.radius_box.changeByDelta)
+ self.radius_label.btn_released.connect(lambda : self.on_param_changed('shadow_radius', self.radius_box.value()))
+ radius_layout = QHBoxLayout()
+ radius_layout.addWidget(self.radius_label)
+ radius_layout.addWidget(self.radius_box)
+
+ hlayout2 = QHBoxLayout()
+ hlayout2.addWidget(self.color_label)
+ hlayout2.addLayout(strength_layout)
+ hlayout2.addLayout(radius_layout)
+
+ yoffset_layout = QHBoxLayout()
+ yoffset_layout.addWidget(self.yoffset_label)
+ yoffset_layout.addWidget(self.yoffset_box)
+
+ offset_label = SmallParamLabel(self.tr('Offset'))
+ offset_label.setSizePolicy(QSizePolicy.Policy.Maximum, QSizePolicy.Policy.Maximum)
+ offset_row = QHBoxLayout()
+ offset_row.addWidget(offset_label)
+ offset_row.addLayout(xoffset_layout)
+ offset_row.addLayout(yoffset_layout)
+
+ layout = QVBoxLayout(self)
+ layout.addLayout(offset_row)
+ layout.addLayout(hlayout2)
+
+ def on_offset_changed(self, *args, **kwargs):
+ self.on_param_changed('shadow_offset', [self.xoffset_box.value(), self.yoffset_box.value()])
+
+
+class TextGradientGroup(QGroupBox):
+ def __init__(self, on_param_changed: Callable = None):
+ super().__init__()
+ self.setTitle(self.tr('Gradient'))
+ self.on_param_changed = on_param_changed
+
+ self.start_picker = SmallColorPickerLabel(self, param_name='gradient_start_color')
+ start_picker_label = SmallParamLabel(self.tr('Start Color'), alignment=Qt.AlignmentFlag.AlignCenter)
+ start_picker_layout = QHBoxLayout()
+ start_picker_layout.addWidget(start_picker_label)
+ start_picker_layout.addWidget(self.start_picker)
+
+ self.end_picker = SmallColorPickerLabel(self, param_name='gradient_end_color')
+ end_picker_label = SmallParamLabel(self.tr('End Color'), alignment=Qt.AlignmentFlag.AlignCenter)
+ end_picker_layout = QHBoxLayout()
+ end_picker_layout.addWidget(end_picker_label)
+ end_picker_layout.addWidget(self.end_picker)
+
+ self.enable_checker = TextCheckerLabel(self.tr('Enable'))
+ self.enable_checker.checkStateChanged.connect(lambda checked: self.on_param_changed('gradient_enabled', checked))
+
+ self.angle_box = SmallSizeComboBox([0, 359], 'gradient_angle', self)
+ self.angle_box.setToolTip(self.tr("Set Gradient Angle"))
+ self.angle_box.param_changed.connect(self.on_param_changed)
+ self.angle_label = SmallSizeControlLabel(self, direction=1, text=self.tr('Angle'), alignment=Qt.AlignmentFlag.AlignCenter)
+ self.angle_label.size_ctrl_changed.connect(lambda x : self.angle_box.changeByDelta(x, multiplier=1))
+ self.angle_label.btn_released.connect(lambda : self.on_param_changed('gradient_angle', self.angle_box.value()))
+ angle_layout = QHBoxLayout()
+ angle_layout.addWidget(self.angle_label)
+ angle_layout.addWidget(self.angle_box)
+
+ self.size_box = SmallSizeComboBox([0.5, 2], 'gradient_size', self)
+ self.size_box.setToolTip(self.tr("Set Gradient Size"))
+ self.size_box.param_changed.connect(self.on_param_changed)
+ self.size_label = SmallSizeControlLabel(self, direction=1, text=self.tr('Size'), alignment=Qt.AlignmentFlag.AlignCenter)
+ self.size_label.size_ctrl_changed.connect(lambda x : self.size_box.changeByDelta(x, multiplier=0.02))
+ self.size_label.btn_released.connect(lambda : self.on_param_changed('gradient_size', self.size_box.value()))
+ size_layout = QHBoxLayout()
+ size_layout.addWidget(self.size_label)
+ size_layout.addWidget(self.size_box)
+
+ hlayout1 = QHBoxLayout()
+ hlayout1.addLayout(start_picker_layout)
+ hlayout1.addLayout(end_picker_layout)
+ hlayout1.addWidget(self.enable_checker)
+ # hlayout1.addStretch(-1)
+
+ hlayout2 = QHBoxLayout()
+ hlayout2.addLayout(angle_layout)
+ hlayout2.addLayout(size_layout)
+
+ layout = QVBoxLayout(self)
+ layout.addLayout(hlayout1)
+ layout.addLayout(hlayout2)
+
+
+class TextAdvancedFormatPanel(PanelArea):
+
+ param_changed = Signal(str, object)
+
+ def __init__(self, panel_name: str, config_name: str, config_expand_name: str, on_format_changed: Callable):
+ super().__init__(panel_name, config_name, config_expand_name)
+
+ self.active_format: FontFormat = None
+ self.on_format_changed = on_format_changed
+
+ self.linespacing_type_combobox = SmallComboBox(
+ parent=self,
+ options=[
+ self.tr("Proportional"),
+ self.tr("Distance")
+ ]
+ )
+ self.linespacing_type_combobox.activated.connect(self.on_linespacing_type_changed)
+ linespacing_type_label = SmallParamLabel(self.tr('Line Spacing Type'))
+ linespacing_type_layout = QHBoxLayout()
+ linespacing_type_layout.addWidget(linespacing_type_label)
+ linespacing_type_layout.addWidget(self.linespacing_type_combobox)
+
+ self.opacity_box = SmallSizeComboBox([0, 1], 'opacity', self, init_value=1.)
+ self.opacity_box.setToolTip(self.tr("Set Text Opacity"))
+ self.opacity_box.param_changed.connect(self.on_format_changed)
+ self.opacity_label = SmallSizeControlLabel(self, direction=1, text=self.tr('Opacity'), alignment=Qt.AlignmentFlag.AlignCenter)
+ self.opacity_label.size_ctrl_changed.connect(self.opacity_box.changeByDelta)
+ self.opacity_label.btn_released.connect(lambda : self.on_format_changed('opacity', self.opacity_box.value()))
+ opacity_layout = QHBoxLayout()
+ opacity_layout.addWidget(self.opacity_label)
+ opacity_layout.addWidget(self.opacity_box)
+
+ # self.tate_chu_yoko_checker = QFontChecker()
+ self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Maximum)
+ self.scrollContent.after_resized.connect(self.adjuset_size)
+
+ self.shadow_group = TextShadowGroup(self.on_format_changed, title=self.tr('Shadow'))
+ self.shadow_group.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Maximum)
+
+ self.gradient_group = TextGradientGroup(self.on_format_changed)
+ self.gradient_group.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Maximum)
+
+ hlayout = QHBoxLayout()
+ hlayout.addLayout(linespacing_type_layout)
+ hlayout.addLayout(opacity_layout)
+ vlayout = QVBoxLayout()
+ vlayout.addLayout(hlayout)
+ vlayout.setAlignment(Qt.AlignmentFlag.AlignTop)
+ vlayout.addWidget(self.shadow_group)
+ vlayout.addWidget(self.gradient_group)
+
+ self.setContentLayout(vlayout)
+ self.vlayout = vlayout
+
+ def adjuset_size(self):
+ TEXT_ADVANCED_PANEL_MAXH = 300
+ self.setFixedHeight(min(TEXT_ADVANCED_PANEL_MAXH, self.scrollContent.height()))
+
+ def on_linespacing_type_changed(self):
+ self.on_format_changed('line_spacing_type', self.linespacing_type_combobox.currentIndex())
+
+ def set_active_format(self, font_format: FontFormat):
+ self.active_format = font_format
+ self.linespacing_type_combobox.setCurrentIndex(font_format.line_spacing_type)
+
+ self.shadow_group.color_label.setPickerColor(font_format.shadow_color)
+ self.shadow_group.strength_box.setValue(font_format.shadow_strength)
+ self.shadow_group.radius_box.setValue(font_format.shadow_radius)
+ self.shadow_group.xoffset_box.setValue(font_format.shadow_offset[0])
+ self.shadow_group.yoffset_box.setValue(font_format.shadow_offset[1])
+
+ self.gradient_group.size_box.setValue(font_format.gradient_size)
+ self.gradient_group.angle_box.setValue(font_format.gradient_angle)
+ self.gradient_group.enable_checker.setCheckState(font_format.gradient_enabled)
+ self.gradient_group.start_picker.setPickerColor(font_format.gradient_start_color)
+ self.gradient_group.end_picker.setPickerColor(font_format.gradient_end_color)
+ # self.tate_chu_yoko_checker.setChecked(font_format.font)
\ No newline at end of file
diff --git a/ui/text_graphical_effect.py b/ui/text_graphical_effect.py
new file mode 100644
index 0000000000000000000000000000000000000000..52a0e824df4bf051661cb6eaae6d02fce61d6495
--- /dev/null
+++ b/ui/text_graphical_effect.py
@@ -0,0 +1,28 @@
+from typing import Union, Tuple, Callable
+
+import cv2
+import numpy as np
+from qtpy.QtGui import QColor, QPixmap, QImage
+
+from .misc import pixmap2ndarray, ndarray2pixmap
+
+
+def apply_shadow_effect(img: Union[QPixmap, QImage, np.ndarray], color: QColor, strength=1.0, radius=21) -> Tuple[
+ QPixmap, np.ndarray, np.ndarray]:
+ if isinstance(color, QColor):
+ color = [color.red(), color.green(), color.blue()]
+
+ if not isinstance(img, np.ndarray):
+ img = pixmap2ndarray(img, keep_alpha=True)
+
+ mask = img[..., -1].copy()
+ ksize = radius * 2 + 1
+ mask = cv2.GaussianBlur(mask, (ksize, ksize), ksize / 6)
+ if strength != 1:
+ mask = np.clip(mask.astype(np.float32) * strength, 0, 255).astype(np.uint8)
+ bg_img = np.zeros((img.shape[0], img.shape[1], 4), dtype=np.uint8)
+ bg_img[..., :3] = np.array(color, np.uint8)
+ bg_img[..., 3] = mask
+
+ result = ndarray2pixmap(bg_img)
+ return result, img
diff --git a/ui/text_panel.py b/ui/text_panel.py
new file mode 100644
index 0000000000000000000000000000000000000000..020057edf0d2ebc90b304c9a287c1e86ed00e004
--- /dev/null
+++ b/ui/text_panel.py
@@ -0,0 +1,564 @@
+import copy
+import sys
+from typing import List
+
+from qtpy.QtWidgets import QLineEdit, QSizePolicy, QHBoxLayout, QVBoxLayout, QFrame, QFontComboBox, QApplication, QPushButton, QLabel, QGroupBox, QCheckBox, QSlider
+from qtpy.QtCore import Signal, Qt
+from qtpy.QtGui import QFocusEvent, QMouseEvent, QTextCursor, QKeyEvent
+
+from utils import shared
+from utils import config as C
+from utils.fontformat import FontFormat, px2pt, LineSpacingType
+from .custom_widget import Widget, ColorPickerLabel, ClickableLabel, CheckableLabel, TextCheckerLabel, AlignmentChecker, QFontChecker, SizeComboBox, SizeControlLabel
+from .textitem import TextBlkItem
+from .text_advanced_format import TextAdvancedFormatPanel
+from .text_style_presets import TextStylePresetPanel
+from . import funcmaps as FM
+
+
+class LineEdit(QLineEdit):
+
+ return_pressed_wochange = Signal()
+ return_pressed = Signal()
+
+ def __init__(self, content: str = None, parent = None):
+ super().__init__(content, parent)
+ self.textChanged.connect(self.on_text_changed)
+ self._text_changed = False
+ self.editingFinished.connect(self.on_editing_finished)
+ # self.returnPressed.connect(self.on_return_pressed)
+
+ def on_text_changed(self):
+ self._text_changed = True
+
+ def on_editing_finished(self):
+ self._text_changed = False
+
+ def focusOutEvent(self, e: QFocusEvent) -> None:
+ self._text_changed = False
+ return super().focusOutEvent(e)
+
+ def keyPressEvent(self, e: QKeyEvent) -> None:
+ super().keyPressEvent(e)
+ if e.key() == Qt.Key.Key_Return:
+ self.return_pressed.emit()
+ if not self._text_changed:
+ self.return_pressed_wochange.emit()
+
+
+class IncrementalBtn(QPushButton):
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.setFixedSize(13, 13)
+
+
+class AlignmentBtnGroup(QFrame):
+ param_changed = Signal(str, int)
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.alignLeftChecker = AlignmentChecker(self)
+ self.alignLeftChecker.clicked.connect(self.alignBtnPressed)
+ self.alignCenterChecker = AlignmentChecker(self)
+ self.alignCenterChecker.clicked.connect(self.alignBtnPressed)
+ self.alignRightChecker = AlignmentChecker(self)
+ self.alignRightChecker.clicked.connect(self.alignBtnPressed)
+ self.alignLeftChecker.setObjectName("AlignLeftChecker")
+ self.alignRightChecker.setObjectName("AlignRightChecker")
+ self.alignCenterChecker.setObjectName("AlignCenterChecker")
+
+ hlayout = QHBoxLayout(self)
+ hlayout.addWidget(self.alignLeftChecker)
+ hlayout.addWidget(self.alignCenterChecker)
+ hlayout.addWidget(self.alignRightChecker)
+ hlayout.setSpacing(0)
+
+ def alignBtnPressed(self):
+ btn = self.sender()
+ if btn == self.alignLeftChecker:
+ self.alignLeftChecker.setChecked(True)
+ self.alignCenterChecker.setChecked(False)
+ self.alignRightChecker.setChecked(False)
+ self.param_changed.emit('alignment', 0)
+ elif btn == self.alignRightChecker:
+ self.alignRightChecker.setChecked(True)
+ self.alignCenterChecker.setChecked(False)
+ self.alignLeftChecker.setChecked(False)
+ self.param_changed.emit('alignment', 2)
+ else:
+ self.alignCenterChecker.setChecked(True)
+ self.alignLeftChecker.setChecked(False)
+ self.alignRightChecker.setChecked(False)
+ self.param_changed.emit('alignment', 1)
+
+ def setAlignment(self, alignment: int):
+ if alignment == 0:
+ self.alignLeftChecker.setChecked(True)
+ self.alignCenterChecker.setChecked(False)
+ self.alignRightChecker.setChecked(False)
+ elif alignment == 1:
+ self.alignLeftChecker.setChecked(False)
+ self.alignCenterChecker.setChecked(True)
+ self.alignRightChecker.setChecked(False)
+ else:
+ self.alignLeftChecker.setChecked(False)
+ self.alignCenterChecker.setChecked(False)
+ self.alignRightChecker.setChecked(True)
+
+
+class FormatGroupBtn(QFrame):
+ param_changed = Signal(str, bool)
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+ self.boldBtn = QFontChecker(self)
+ self.boldBtn.setObjectName("FontBoldChecker")
+ self.boldBtn.clicked.connect(self.setBold)
+ self.italicBtn = QFontChecker(self)
+ self.italicBtn.setObjectName("FontItalicChecker")
+ self.italicBtn.clicked.connect(self.setItalic)
+ self.underlineBtn = QFontChecker(self)
+ self.underlineBtn.setObjectName("FontUnderlineChecker")
+ self.underlineBtn.clicked.connect(self.setUnderline)
+ hlayout = QHBoxLayout(self)
+ hlayout.addWidget(self.boldBtn)
+ hlayout.addWidget(self.italicBtn)
+ hlayout.addWidget(self.underlineBtn)
+ hlayout.setSpacing(0)
+
+ def setBold(self):
+ self.param_changed.emit('bold', self.boldBtn.isChecked())
+
+ def setItalic(self):
+ self.param_changed.emit('italic', self.italicBtn.isChecked())
+
+ def setUnderline(self):
+ self.param_changed.emit('underline', self.underlineBtn.isChecked())
+
+
+class FontSizeBox(QFrame):
+ param_changed = Signal(str, float)
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+ self.upBtn = IncrementalBtn(self)
+ self.upBtn.setObjectName("FsizeIncrementUp")
+ self.downBtn = IncrementalBtn(self)
+ self.downBtn.setObjectName("FsizeIncrementDown")
+ self.upBtn.clicked.connect(self.onUpBtnClicked)
+ self.downBtn.clicked.connect(self.onDownBtnClicked)
+ self.fcombobox = SizeComboBox([1, 1000], 'font_size', self)
+ self.fcombobox.addItems([
+ "5", "5.5", "6.5", "7.5", "8", "9", "10", "10.5",
+ "11", "12", "14", "16", "18", "20", '22', "26", "28",
+ "36", "48", "56", "72", "93", "123", "163"
+ ])
+ self.fcombobox.param_changed.connect(self.param_changed)
+
+ hlayout = QHBoxLayout(self)
+ vlayout = QVBoxLayout()
+ vlayout.addWidget(self.upBtn)
+ vlayout.addWidget(self.downBtn)
+ vlayout.setContentsMargins(0, 0, 0, 0)
+ vlayout.setSpacing(0)
+ hlayout.addLayout(vlayout)
+ hlayout.addWidget(self.fcombobox)
+ hlayout.setSpacing(3)
+ hlayout.setContentsMargins(0, 0, 0, 0)
+
+ def getFontSize(self) -> str:
+ return self.fcombobox.currentText()
+
+ def onUpBtnClicked(self):
+ raito = 1.25
+ size = self.getFontSize()
+ multi_size=False
+ if "+" in size:
+ size = size.strip("+")
+ multi_size=True
+ size = float(size)
+ newsize = int(round(size * raito))
+ if newsize == size:
+ newsize += 1
+ newsize = min(1000, newsize)
+ if newsize != size:
+ if not multi_size:
+ self.param_changed.emit('font_size', newsize)
+ self.fcombobox.setCurrentText(str(newsize))
+ else:
+ self.param_changed.emit('rel_font_size', raito)
+ self.fcombobox.setCurrentText(str(newsize)+"+")
+
+ def onDownBtnClicked(self):
+ raito = 0.75
+ size = self.getFontSize()
+ multi_size=False
+ if "+" in size:
+ size = size.strip("+")
+ multi_size=True
+ size = float(size)
+ newsize = int(round(size * raito))
+ if newsize == size:
+ newsize -= 1
+ newsize = max(1, newsize)
+ if newsize != size:
+ if not multi_size:
+ self.param_changed.emit('font_size', newsize)
+ self.fcombobox.setCurrentText(str(newsize))
+ else:
+ self.param_changed.emit('rel_font_size', raito)
+ self.fcombobox.setCurrentText(str(newsize)+"+")
+
+
+class FontFamilyComboBox(QFontComboBox):
+ param_changed = Signal(str, object)
+ def __init__(self, emit_if_focused=True, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+ self.currentFontChanged.connect(self.on_fontfamily_changed)
+ self.lineedit = lineedit = LineEdit(parent=self)
+ lineedit.return_pressed.connect(self.on_return_pressed)
+ self.setLineEdit(lineedit)
+ self.emit_if_focused = emit_if_focused
+ self.return_pressed = False
+
+ def apply_fontfamily(self):
+ ffamily = self.currentFont().family()
+ if ffamily in shared.FONT_FAMILIES:
+ self.param_changed.emit('font_family', ffamily)
+
+ def update_font_list(self, font_list):
+ self.currentFontChanged.disconnect(self.on_fontfamily_changed)
+ current_font = self.currentFont().family()
+ self.clear()
+ self.addItems(font_list)
+ self.addItems([current_font])
+ self.setCurrentText(current_font)
+ self.currentFontChanged.connect(self.on_fontfamily_changed)
+
+ def on_return_pressed(self):
+ self.return_pressed = True
+ self.apply_fontfamily()
+
+ def on_fontfamily_changed(self):
+ if self.return_pressed:
+ self.return_pressed = False
+ else:
+ self.apply_fontfamily()
+
+
+class FontFormatPanel(Widget):
+
+ textblk_item: TextBlkItem = None
+ text_cursor: QTextCursor = None
+ global_format: FontFormat = None
+ restoring_textblk: bool = False
+
+ def __init__(self, app: QApplication, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+ self.app = app
+
+ self.vlayout = QVBoxLayout(self)
+ self.vlayout.setAlignment(Qt.AlignmentFlag.AlignTop)
+ self.familybox = FontFamilyComboBox(emit_if_focused=True, parent=self)
+ self.familybox.setContentsMargins(0, 0, 0, 0)
+ self.familybox.setObjectName("FontFamilyBox")
+ self.familybox.setToolTip(self.tr("Font Family"))
+ self.familybox.param_changed.connect(self.on_param_changed)
+ self.familybox.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+
+ self.fontsizebox = FontSizeBox(self)
+ self.fontsizebox.setToolTip(self.tr("Font Size"))
+ self.fontsizebox.setObjectName("FontSizeBox")
+ self.fontsizebox.fcombobox.setToolTip(self.tr("Change font size"))
+ self.fontsizebox.param_changed.connect(self.on_param_changed)
+
+ self.lineSpacingLabel = SizeControlLabel(self, direction=1, transparent_bg=False)
+ self.lineSpacingLabel.setObjectName("lineSpacingLabel")
+ self.lineSpacingLabel.size_ctrl_changed.connect(self.onLineSpacingCtrlChanged)
+ self.lineSpacingLabel.btn_released.connect(lambda : self.on_param_changed('line_spacing', self.lineSpacingBox.value()))
+
+ self.lineSpacingBox = SizeComboBox([0, 100], 'line_spacing', self)
+ self.lineSpacingBox.addItems(["1.0", "1.1", "1.2"])
+ self.lineSpacingBox.setToolTip(self.tr("Change line spacing"))
+ self.lineSpacingBox.param_changed.connect(self.on_param_changed)
+
+ self.colorPicker = ColorPickerLabel(self, param_name='frgb')
+ self.colorPicker.setToolTip(self.tr("Change font color"))
+ self.colorPicker.changingColor.connect(self.changingColor)
+ self.colorPicker.colorChanged.connect(self.onColorLabelChanged)
+ self.colorPicker.apply_color.connect(self.on_apply_color)
+
+ self.alignBtnGroup = AlignmentBtnGroup(self)
+ self.alignBtnGroup.param_changed.connect(self.on_param_changed)
+
+ self.formatBtnGroup = FormatGroupBtn(self)
+ self.formatBtnGroup.param_changed.connect(self.on_param_changed)
+
+ self.verticalChecker = QFontChecker(self)
+ self.verticalChecker.setObjectName("FontVerticalChecker")
+ self.verticalChecker.clicked.connect(lambda : self.on_param_changed('vertical', self.verticalChecker.isChecked()))
+
+ self.strokeWidthBox = SizeComboBox([0, 10], 'stroke_width', self)
+ self.strokeWidthBox.addItems(["0.1"])
+ self.strokeWidthBox.setToolTip(self.tr("Change stroke width"))
+ self.strokeWidthBox.param_changed.connect(self.on_param_changed)
+
+ self.fontStrokeLabel = SizeControlLabel(self, 0, self.tr("Stroke"))
+ self.fontStrokeLabel.setObjectName("fontStrokeLabel")
+ font = self.fontStrokeLabel.font()
+ font.setPointSizeF(shared.CONFIG_FONTSIZE_CONTENT * 0.95)
+ self.fontStrokeLabel.setFont(font)
+ self.fontStrokeLabel.size_ctrl_changed.connect(self.strokeWidthBox.changeByDelta)
+ self.fontStrokeLabel.btn_released.connect(lambda : self.on_param_changed('stroke_width', self.strokeWidthBox.value()))
+
+ self.strokeColorPicker = ColorPickerLabel(self, param_name='srgb')
+ self.strokeColorPicker.setToolTip(self.tr("Change stroke color"))
+ self.strokeColorPicker.changingColor.connect(self.changingColor)
+ self.strokeColorPicker.colorChanged.connect(self.onColorLabelChanged)
+ self.strokeColorPicker.apply_color.connect(self.on_apply_color)
+
+ stroke_hlayout = QHBoxLayout()
+ stroke_hlayout.addWidget(self.fontStrokeLabel)
+ stroke_hlayout.addWidget(self.strokeWidthBox)
+ stroke_hlayout.addWidget(self.strokeColorPicker)
+ stroke_hlayout.setSpacing(shared.WIDGET_SPACING_CLOSE)
+
+ self.letterSpacingBox = SizeComboBox([0, 10], "letter_spacing", self)
+ self.letterSpacingBox.addItems(["0.0"])
+ self.letterSpacingBox.setToolTip(self.tr("Change letter spacing"))
+ self.letterSpacingBox.setMinimumWidth(int(self.letterSpacingBox.height() * 2.5))
+ self.letterSpacingBox.param_changed.connect(self.on_param_changed)
+
+ self.letterSpacingLabel = SizeControlLabel(self, direction=0, transparent_bg=False)
+ self.letterSpacingLabel.setObjectName("letterSpacingLabel")
+ self.letterSpacingLabel.size_ctrl_changed.connect(self.letterSpacingBox.changeByDelta)
+ self.letterSpacingLabel.btn_released.connect(lambda : self.on_param_changed('letter_spacing', self.letterSpacingBox.value()))
+
+ lettersp_hlayout = QHBoxLayout()
+ lettersp_hlayout.addWidget(self.letterSpacingLabel)
+ lettersp_hlayout.addWidget(self.letterSpacingBox)
+ lettersp_hlayout.setSpacing(shared.WIDGET_SPACING_CLOSE)
+
+ self.global_fontfmt_str = self.tr("Global Font Format")
+ self.textstyle_panel = TextStylePresetPanel(
+ self.global_fontfmt_str,
+ config_name='show_text_style_preset',
+ config_expand_name='expand_tstyle_panel'
+ )
+ self.textstyle_panel.active_text_style_label_changed.connect(self.on_active_textstyle_label_changed)
+ self.textstyle_panel.active_stylename_edited.connect(self.on_active_stylename_edited)
+
+ self.textadvancedfmt_panel = TextAdvancedFormatPanel(
+ self.tr('Advanced Text Format'),
+ config_name='text_advanced_format_panel',
+ config_expand_name='expand_tadvanced_panel',
+ on_format_changed=self.on_param_changed
+ )
+ color_label = self.textadvancedfmt_panel.shadow_group.color_label
+ color_label.changingColor.connect(self.changingColor)
+ color_label.colorChanged.connect(self.onColorLabelChanged)
+ color_label.apply_color.connect(self.on_apply_color)
+
+ color_label = self.textadvancedfmt_panel.gradient_group.start_picker
+ color_label.changingColor.connect(self.changingColor)
+ color_label.colorChanged.connect(self.onColorLabelChanged)
+ color_label.apply_color.connect(self.on_apply_color)
+
+ color_label = self.textadvancedfmt_panel.gradient_group.end_picker
+ color_label.changingColor.connect(self.changingColor)
+ color_label.colorChanged.connect(self.onColorLabelChanged)
+ color_label.apply_color.connect(self.on_apply_color)
+
+ self.foldTextBtn = CheckableLabel(self.tr("Unfold"), self.tr("Fold"), False)
+ self.sourceBtn = TextCheckerLabel(self.tr("Source"))
+ self.transBtn = TextCheckerLabel(self.tr("Translation"))
+
+ FONTFORMAT_SPACING = 6
+
+ vl0 = QVBoxLayout()
+ vl0.addWidget(self.textstyle_panel.view_widget)
+ vl0.addWidget(self.textadvancedfmt_panel.view_widget)
+ vl0.setSpacing(0)
+ vl0.setContentsMargins(0, 0, 0, 0)
+ hl1 = QHBoxLayout()
+ hl1.addWidget(self.familybox)
+ hl1.addWidget(self.fontsizebox)
+ hl1.addWidget(self.lineSpacingLabel)
+ hl1.addWidget(self.lineSpacingBox)
+ hl1.setSpacing(4)
+ hl1.setContentsMargins(0, 12, 0, 0)
+ hl2 = QHBoxLayout()
+ hl2.setAlignment(Qt.AlignmentFlag.AlignCenter)
+ hl2.addWidget(self.colorPicker)
+ hl2.addWidget(self.alignBtnGroup)
+ hl2.addWidget(self.formatBtnGroup)
+ hl2.addWidget(self.verticalChecker)
+ hl2.setSpacing(FONTFORMAT_SPACING)
+ hl2.setContentsMargins(0, 0, 0, 0)
+ hl3 = QHBoxLayout()
+ hl3.setAlignment(Qt.AlignmentFlag.AlignCenter)
+ hl3.addLayout(stroke_hlayout)
+ hl3.addLayout(lettersp_hlayout)
+ hl3.setContentsMargins(3, 0, 3, 0)
+ hl3.setSpacing(13)
+ hl4 = QHBoxLayout()
+ hl4.setAlignment(Qt.AlignmentFlag.AlignCenter)
+ hl4.addWidget(self.foldTextBtn)
+ hl4.addWidget(self.sourceBtn)
+ hl4.addWidget(self.transBtn)
+ hl4.setStretch(0, 1)
+ hl4.setStretch(1, 1)
+ hl4.setStretch(2, 1)
+ hl4.setContentsMargins(0, 12, 0, 0)
+ hl4.setSpacing(0)
+
+ self.vlayout.addLayout(vl0)
+ self.vlayout.addLayout(hl1)
+ self.vlayout.addLayout(hl2)
+ self.vlayout.addLayout(hl3)
+ self.vlayout.addLayout(hl4)
+ self.vlayout.setContentsMargins(0, 0, 7, 0)
+ self.vlayout.setSpacing(0)
+
+ self.focusOnColorDialog = False
+ C.active_format = self.global_format
+
+ def global_mode(self):
+ return id(C.active_format) == id(self.global_format)
+
+ def active_text_style_label(self):
+ return self.textstyle_panel.active_text_style_label
+
+ def active_text_style_format(self):
+ af = self.active_text_style_label()
+ if af is not None:
+ return af.fontfmt
+ else:
+ return None
+
+ def on_param_changed(self, param_name: str, value):
+ func = FM.handle_ffmt_change.get(param_name)
+ func_kwargs = {}
+ if param_name in {'font_size', 'rel_font_size'}:
+ func_kwargs['clip_size'] = True
+ if self.global_mode():
+ func(param_name, value, self.global_format, is_global=True, **func_kwargs)
+ self.update_text_style_label()
+ else:
+ func(param_name, value, C.active_format, is_global=False, blkitems=self.textblk_item, set_focus=True, **func_kwargs)
+
+ def update_text_style_label(self):
+ if self.global_mode():
+ active_text_style_label = self.active_text_style_label()
+ if active_text_style_label is not None:
+ active_text_style_label.update_style(self.global_format)
+
+ def changingColor(self):
+ self.focusOnColorDialog = True
+
+ def onColorLabelChanged(self, is_valid=True):
+ self.focusOnColorDialog = False
+ if is_valid:
+ sender: ColorPickerLabel = self.sender()
+ rgb = sender.rgb()
+ self.on_param_changed(sender.param_name, rgb)
+
+ def on_apply_color(self, param_name, rgb):
+ self.on_param_changed(param_name, rgb)
+
+ def onLineSpacingCtrlChanged(self, delta: int):
+ if C.active_format.line_spacing_type == LineSpacingType.Distance:
+ mul = 0.1
+ else:
+ mul = 0.01
+ self.lineSpacingBox.setValue(self.lineSpacingBox.value() + delta * mul)
+
+ def set_active_format(self, font_format: FontFormat, multi_size=False):
+ C.active_format = font_format
+ self.familybox.blockSignals(True)
+ font_size = round(font_format.font_size, 1)
+ if int(font_size) == font_size:
+ font_size = str(int(font_size))
+ else:
+ font_size = f'{font_size:.1f}'
+ if multi_size:
+ font_size += "+"
+ self.fontsizebox.fcombobox.setCurrentText(font_size)
+ self.familybox.setCurrentText(font_format.font_family)
+ self.colorPicker.setPickerColor(font_format.foreground_color())
+ self.strokeColorPicker.setPickerColor(font_format.stroke_color())
+ self.strokeWidthBox.setValue(font_format.stroke_width)
+ self.lineSpacingBox.setValue(font_format.line_spacing)
+ self.letterSpacingBox.setValue(font_format.letter_spacing)
+ self.verticalChecker.setChecked(font_format.vertical)
+ self.formatBtnGroup.boldBtn.setChecked(font_format.bold)
+ self.formatBtnGroup.underlineBtn.setChecked(font_format.underline)
+ self.formatBtnGroup.italicBtn.setChecked(font_format.italic)
+ self.alignBtnGroup.setAlignment(font_format.alignment)
+
+ self.familybox.blockSignals(False)
+ self.textadvancedfmt_panel.set_active_format(font_format)
+
+ def set_globalfmt_title(self):
+ active_text_style_label = self.active_text_style_label()
+ if active_text_style_label is None:
+ self.textstyle_panel.setTitle(self.global_fontfmt_str)
+ else:
+ title = self.global_fontfmt_str + ' - ' + active_text_style_label.fontfmt._style_name
+ valid_title = self.textstyle_panel.elidedText(title)
+ self.textstyle_panel.setTitle(valid_title)
+
+
+ def deactivate_style_label(self):
+ if self.active_text_style_label() is not None:
+ self.textstyle_panel.on_stylelabel_activated(False)
+
+
+ def on_active_textstyle_label_changed(self):
+ '''
+ merge activate textstyle into global format
+ '''
+ active_text_style_label = self.active_text_style_label()
+ if active_text_style_label is not None:
+ updated_keys = self.global_format.merge(active_text_style_label.fontfmt, compare=True)
+ if self.global_mode() and len(updated_keys) > 0:
+ self.set_active_format(self.global_format)
+ self.set_globalfmt_title()
+ else:
+ if self.global_mode():
+ self.set_globalfmt_title()
+
+ def on_active_stylename_edited(self):
+ if self.global_mode():
+ self.set_globalfmt_title()
+
+ def set_textblk_item(self, textblk_item: TextBlkItem = None, multi_select:bool=False):
+ if textblk_item is None:
+ focus_w = self.app.focusWidget()
+ focus_p = None if focus_w is None else focus_w.parentWidget()
+ focus_on_fmtoptions = False
+ if self.focusOnColorDialog:
+ focus_on_fmtoptions = True
+ elif focus_p:
+ if focus_p == self or focus_p.parentWidget() == self:
+ focus_on_fmtoptions = True
+ if not focus_on_fmtoptions:
+ # Store the current text block's format before switching to global
+ if self.textblk_item is not None:
+ # Save all format properties including gradient state
+ self.textblk_item.fontformat = copy.deepcopy(C.active_format)
+ self.textblk_item = None
+ self.set_active_format(self.global_format, multi_select)
+ self.set_globalfmt_title()
+
+ else:
+ if not self.restoring_textblk:
+ blk_fmt = textblk_item.get_fontformat()
+ # Preserve gradient properties from the text block's format
+ if hasattr(textblk_item.fontformat, 'gradient_enabled'):
+ blk_fmt.gradient_enabled = textblk_item.fontformat.gradient_enabled
+ blk_fmt.gradient_start_color = textblk_item.fontformat.gradient_start_color
+ blk_fmt.gradient_end_color = textblk_item.fontformat.gradient_end_color
+ blk_fmt.gradient_angle = textblk_item.fontformat.gradient_angle
+ blk_fmt.gradient_size = textblk_item.fontformat.gradient_size
+ self.textblk_item = textblk_item
+ multi_size = not textblk_item.isEditing() and textblk_item.isMultiFontSize()
+ self.set_active_format(blk_fmt, multi_size)
+ self.textstyle_panel.setTitle(f'TextBlock #{textblk_item.idx}')
diff --git a/ui/text_style_presets.py b/ui/text_style_presets.py
new file mode 100644
index 0000000000000000000000000000000000000000..6cb6e046116f337b6a02010ea144a0361a14b958
--- /dev/null
+++ b/ui/text_style_presets.py
@@ -0,0 +1,456 @@
+from typing import List
+
+from qtpy.QtWidgets import QMenu, QMessageBox, QStackedLayout, QGraphicsDropShadowEffect, QLineEdit, QSizePolicy, QHBoxLayout, QVBoxLayout, QPushButton, QLabel
+from qtpy.QtCore import Signal, Qt, QRectF
+from qtpy.QtGui import QMouseEvent, QFontMetrics, QColor, QPixmap, QPainter, QContextMenuEvent
+
+
+from utils.fontformat import FontFormat
+from utils.config import save_text_styles, text_styles
+from utils import config as C
+from .custom_widget import PanelArea, Widget, FlowLayout
+
+
+class ArrowLeftButton(QPushButton):
+ pass
+
+
+class ArrowRightButton(QPushButton):
+ pass
+
+
+class DeleteStyleButton(QPushButton):
+ pass
+
+
+class StyleLabel(QLineEdit):
+
+ edit_finished = Signal()
+
+ def __init__(self, style_name: str = None, parent = None):
+ super().__init__(parent=parent)
+
+ self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, True)
+ self.setStyleSheet("background-color: rgba(0, 0, 0, 0); border: none")
+ self.setTextMargins(0, 0, 0, 0)
+ self.setContentsMargins(0, 0, 0, 0)
+
+ self.editingFinished.connect(self.edit_finished)
+ self.setEnabled(False)
+
+ if style_name is not None:
+ self.setText(style_name)
+
+ self.resizeToContent()
+ self.edit_finished.connect(self.resizeToContent)
+
+ def focusOutEvent(self, e) -> None:
+ super().focusOutEvent(e)
+ self.edit_finished.emit()
+
+ def resizeToContent(self):
+ fm = QFontMetrics(self.font())
+ text = self.text()
+ w = fm.boundingRect(text).width() + 5
+
+ self.setFixedWidth(max(w, 32))
+
+
+class TextStyleLabel(Widget):
+
+ style_name_edited = Signal()
+ delete_btn_clicked = Signal()
+ stylelabel_activated = Signal(bool)
+ apply_fontfmt = Signal(FontFormat)
+
+ def __init__(self, style_name: str = '', parent: Widget = None, fontfmt: FontFormat = None, active_stylename_edited: Signal = None):
+ super().__init__(parent=parent)
+ self._double_clicked = False
+ self.active = False
+ if fontfmt is None:
+ if C.active_format is None:
+ self.fontfmt = FontFormat()
+ else:
+ self.fontfmt = C.active_format.copy()
+ self.fontfmt._style_name = style_name
+ else:
+ self.fontfmt = fontfmt
+ style_name = fontfmt._style_name
+
+ # following subwidgets must have parents, otherwise they kinda of pop up when creating it
+ self.active_stylename_edited = active_stylename_edited
+ self.stylelabel = StyleLabel(style_name, parent=self)
+ self.stylelabel.edit_finished.connect(self.on_style_name_edited)
+ self.setSizePolicy(QSizePolicy.Policy.Maximum, QSizePolicy.Policy.Maximum)
+
+ self.setToolTip(self.tr('Click to set as Global format. Double click to edit name.'))
+ self.setCursor(Qt.CursorShape.PointingHandCursor)
+
+ BTN_SIZE = 14
+ self.colorw = colorw = QLabel(parent=self)
+ self.colorw.setAlignment(Qt.AlignmentFlag.AlignCenter)
+ self.colorw.setStyleSheet("border-radius: 7px; border: none; background-color: rgba(0, 0, 0, 0);")
+ d = int(BTN_SIZE * 2)
+ self.colorw.setFixedSize(d, d)
+
+ self.apply_btn = ArrowLeftButton(parent=self)
+ self.apply_btn.setFixedSize(d, BTN_SIZE)
+ self.apply_btn.setToolTip(self.tr('Apply Text Style'))
+ self.apply_btn.clicked.connect(self.on_applybtn_clicked)
+ self.update_btn = ArrowRightButton(parent=self)
+ self.update_btn.setFixedSize(d, BTN_SIZE)
+ self.update_btn.clicked.connect(self.on_updatebtn_clicked)
+ self.update_btn.setToolTip(self.tr('Update from active style'))
+ applyw = Widget(parent=self)
+ applyw.setStyleSheet("border-radius: 7px; border: none")
+ applylayout = QVBoxLayout(applyw)
+ applylayout.setSpacing(0)
+ applylayout.setContentsMargins(0, 0, 0, 0)
+ applylayout.addWidget(self.apply_btn)
+ applylayout.addWidget(self.update_btn)
+
+ self.leftstack = QStackedLayout()
+ self.leftstack.setContentsMargins(0, 0, 0, 0)
+ self.leftstack.addWidget(colorw)
+ self.leftstack.addWidget(applyw)
+
+ self.delete_btn = DeleteStyleButton(parent=self)
+ dsize = BTN_SIZE // 3 * 2
+ self.delete_btn.setFixedSize(dsize, dsize)
+ self.delete_btn.setToolTip(self.tr("Delete Style"))
+ self.delete_btn.clicked.connect(self.on_delete_btn_clicked)
+ self.delete_btn.setStyleSheet("border: none")
+
+ hlayout = QHBoxLayout(self)
+ hlayout.setContentsMargins(0, 0, 3, 0)
+ hlayout.setSpacing(0)
+ hlayout.addLayout(self.leftstack)
+ hlayout.addWidget(self.stylelabel)
+ hlayout.addWidget(self.delete_btn)
+
+ self.updatePreview()
+
+ def on_delete_btn_clicked(self, *args, **kwargs):
+ self.delete_btn_clicked.emit()
+
+ def on_updatebtn_clicked(self, *args, **kwargs):
+ self.update_style()
+
+ def on_applybtn_clicked(self, *args, **kwargs):
+ self.apply_fontfmt.emit(self.fontfmt)
+
+ def update_style(self, fontfmt: FontFormat = None):
+ if fontfmt is None:
+ fontfmt = C.active_format
+ if fontfmt is None:
+ return
+ updated_keys = self.fontfmt.merge(fontfmt, compare=True)
+ if len(updated_keys) > 0:
+ save_text_styles()
+
+ preview_keys = {'font_family', 'frgb', 'srgb', 'stroke_width'}
+ for k in updated_keys:
+ if k in preview_keys:
+ self.updatePreview()
+ break
+
+ def setActive(self, active: bool):
+ self.active = active
+ if active:
+ self.setStyleSheet("border: 2px solid rgb(30, 147, 229)")
+ else:
+ self.setStyleSheet("")
+
+ def mouseReleaseEvent(self, event: QMouseEvent) -> None:
+ if event.button() == Qt.MouseButton.LeftButton:
+ if self._double_clicked:
+ self._double_clicked = False
+ else:
+ active = not self.active
+ self.setActive(active)
+ self.stylelabel_activated.emit(active)
+ return super().mouseReleaseEvent(event)
+
+ def updatePreview(self):
+ font = self.stylelabel.font()
+ font.setFamily(self.fontfmt.font_family)
+ self.stylelabel.setFont(font)
+
+ d = int(self.colorw.width() * 0.66)
+ radius = d / 2
+ pixmap = QPixmap(d, d)
+ pixmap.fill(Qt.GlobalColor.transparent)
+
+ painter = QPainter(pixmap)
+ painter.setRenderHints(QPainter.Antialiasing)
+ painter.setPen(Qt.NoPen)
+
+ draw_rect, draw_radius = QRectF(0, 0, d, d), radius
+ if self.fontfmt.stroke_width > 0:
+ r, g, b = self.fontfmt.stroke_color()
+ color = QColor(r, g, b, 255)
+ painter.setBrush(color)
+ painter.drawRoundedRect(draw_rect, draw_radius, draw_radius)
+ draw_radius = draw_radius * 0.66
+ offset = d / 2 - draw_radius
+ draw_rect = QRectF(offset, offset, draw_radius*2, draw_radius*2)
+
+ r, g, b = self.fontfmt.frgb
+ color = QColor(r, g, b, 255)
+ painter.setBrush(color)
+ painter.drawRoundedRect(draw_rect, draw_radius, draw_radius)
+ painter.end()
+ self.colorw.setPixmap(pixmap)
+
+ self.stylelabel.resizeToContent()
+
+ def mouseDoubleClickEvent(self, event: QMouseEvent) -> None:
+ self._double_clicked = True
+ self.startEdit()
+ return super().mouseDoubleClickEvent(event)
+
+ def startEdit(self, select_all=False):
+ self.stylelabel.setEnabled(True)
+ self.stylelabel.setFocus()
+ self.setCursor(Qt.CursorShape.IBeamCursor)
+ if select_all:
+ self.stylelabel.selectAll()
+
+ def setHoverEffect(self, hover: bool):
+ try:
+ if hover:
+ se = QGraphicsDropShadowEffect()
+ se.setBlurRadius(6)
+ se.setOffset(0, 0)
+ se.setColor(QColor(30, 147, 229))
+ self.setGraphicsEffect(se)
+ else:
+ self.setGraphicsEffect(None)
+ except RuntimeError:
+ pass
+
+ def enterEvent(self, event) -> None:
+ self.setHoverEffect(True)
+ self.leftstack.setCurrentIndex(1)
+ self.delete_btn.setStyleSheet("image: url(icons/titlebar_close.svg); border: none")
+ return super().enterEvent(event)
+
+ def leaveEvent(self, event) -> None:
+ self.setHoverEffect(False)
+ self.leftstack.setCurrentIndex(0)
+ self.delete_btn.setStyleSheet("image: \"none\"; border: none")
+ return super().leaveEvent(event)
+
+ def on_style_name_edited(self):
+ self.setCursor(Qt.CursorShape.PointingHandCursor)
+ self.stylelabel.setEnabled(False)
+ new_name = self.stylelabel.text()
+ if self.fontfmt._style_name != new_name:
+ self.fontfmt._style_name = new_name
+ save_text_styles()
+
+ if self.active and self.active_stylename_edited is not None:
+ self.active_stylename_edited.emit()
+
+ self._double_clicked = False
+
+
+class TextAreaStyleButton(QPushButton):
+ pass
+
+
+class TextStylePresetPanel(PanelArea):
+
+ entered = False
+ active_text_style_label_changed = Signal()
+ apply_fontfmt = Signal(FontFormat)
+ active_stylename_edited = Signal()
+ export_style = Signal()
+ import_style = Signal()
+
+ def __init__(self, panel_name: str, config_name: str, config_expand_name: str):
+ super().__init__(panel_name, config_name, config_expand_name)
+
+ self.active_text_style_label: TextStyleLabel = None
+ self.flayout = FlowLayout()
+ self.default_preset_name = self.tr('Style')
+
+ self.new_btn = TextAreaStyleButton()
+ self.new_btn.setObjectName("NewTextStyleButton")
+ self.new_btn.setToolTip(self.tr("New Text Style"))
+ self.new_btn.clicked.connect(self.on_newbtn_clicked)
+
+ self.clear_btn = TextAreaStyleButton()
+ self.clear_btn.setObjectName("ClearTextStyleButton")
+ self.clear_btn.setToolTip(self.tr("Remove All"))
+ self.clear_btn.clicked.connect(self.on_clearbtn_clicked)
+
+ self.flayout.addWidget(self.new_btn)
+ self.flayout.addWidget(self.clear_btn)
+ self.setContentLayout(self.flayout)
+
+ def on_newbtn_clicked(self, clicked = None):
+ textstylelabel = self.new_textstyle_label()
+ textstylelabel.startEdit(select_all=True)
+ self.resizeToContent()
+
+ def on_clearbtn_clicked(self, clicked = None):
+ msg = QMessageBox()
+ msg.setText(self.tr('Remove all styles?'))
+ msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+ ret = msg.exec_()
+ if ret == QMessageBox.StandardButton.Yes:
+ self.clearStyles()
+
+ def count(self):
+ return self.flayout.count() - 2
+
+ def isEmpty(self):
+ return self.count() < 1
+
+ def new_textstyle_label(self, preset_name: str = None):
+ if preset_name is None:
+ sno = str(self.count() + 1)
+ if len(sno) < 2:
+ preset_name = self.default_preset_name + ' ' + sno
+ else:
+ preset_name = self.default_preset_name + sno
+ textstylelabel = TextStyleLabel(preset_name, active_stylename_edited=self.active_stylename_edited)
+ textstylelabel.stylelabel_activated.connect(self.on_stylelabel_activated)
+ textstylelabel.delete_btn_clicked.connect(self.on_deletebtn_clicked)
+ textstylelabel.apply_fontfmt.connect(self.apply_fontfmt)
+ self.flayout.insertWidget(self.count(), textstylelabel)
+ text_styles.append(textstylelabel.fontfmt)
+ save_text_styles()
+ return textstylelabel
+
+ def resizeToContent(self):
+ TEXTSTYLEAREA_MAXH = 200
+ self.setFixedHeight(min(TEXTSTYLEAREA_MAXH, self.flayout.heightForWidth(self.width())))
+
+ def resizeEvent(self, e):
+ self.resizeToContent()
+ return super().resizeEvent(e)
+
+ def showNewBtn(self):
+ if not self.new_btn.isVisible():
+ self.new_btn.show()
+ self.clear_btn.show()
+ self.resizeToContent()
+
+ def hideNewBtn(self):
+ if self.new_btn.isVisible():
+ self.new_btn.hide()
+ self.clear_btn.hide()
+ self.resizeToContent()
+
+ def updateNewBtnVisibility(self):
+ if self.isEmpty() or self.entered:
+ self.showNewBtn()
+ else:
+ self.hideNewBtn()
+
+ def enterEvent(self, event) -> None:
+ self.entered = True
+ self.showNewBtn()
+ return super().enterEvent(event)
+
+ def leaveEvent(self, event) -> None:
+ self.entered = False
+ if not self.isEmpty():
+ self.hideNewBtn()
+ return super().leaveEvent(event)
+
+ def _clear_styles(self):
+ self.active_text_style_label = None
+ for _ in range(self.count()):
+ w: TextStyleLabel = self.flayout.takeAt(0)
+ if w is not None:
+ if w.active:
+ w.setActive(False)
+ self.active_text_style_label_changed.emit()
+ w.deleteLater()
+
+ def _add_style_label(self, fontfmt: FontFormat):
+ textstylelabel = TextStyleLabel(fontfmt=fontfmt, active_stylename_edited=self.active_stylename_edited)
+ textstylelabel.delete_btn_clicked.connect(self.on_deletebtn_clicked)
+ textstylelabel.stylelabel_activated.connect(self.on_stylelabel_activated)
+ textstylelabel.apply_fontfmt.connect(self.apply_fontfmt)
+ self.flayout.insertWidget(self.count(), textstylelabel)
+
+ def on_deletebtn_clicked(self):
+ w: TextStyleLabel = self.sender()
+ self.removeStyleLabel(w)
+
+ def on_stylelabel_activated(self, active: bool):
+ if self.active_text_style_label is not None:
+ self.active_text_style_label.setActive(False)
+ self.active_text_style_label = None
+ if active:
+ self.active_text_style_label = self.sender()
+ self.active_text_style_label_changed.emit()
+
+ def clearStyles(self):
+ if self.isEmpty():
+ return
+ self._clear_styles()
+ self.updateNewBtnVisibility()
+ text_styles.clear()
+ save_text_styles()
+
+ def removeStyleLabel(self, w: TextStyleLabel):
+ for i, item in enumerate(self.flayout._items):
+ if item.widget() is w:
+ if w is self.active_text_style_label:
+ w.setActive(False)
+ self.active_text_style_label = None
+ self.active_text_style_label_changed.emit()
+ self.flayout.takeAt(i)
+ self.flayout.update()
+ self.updateNewBtnVisibility()
+ text_styles.pop(i)
+ save_text_styles()
+ w.deleteLater()
+ self.resizeToContent()
+ break
+
+ def initStyles(self, styles: List[FontFormat]):
+ assert self.isEmpty()
+ for style in styles:
+ self._add_style_label(style)
+ if not self.isEmpty():
+ self.new_btn.hide()
+ self.clear_btn.hide()
+ self.resizeToContent()
+
+ def setStyles(self, styles: List[FontFormat], save_styles = False):
+ self._clear_styles()
+ for style in styles:
+ self._add_style_label(style)
+
+ self.updateNewBtnVisibility()
+ self.resizeToContent()
+ if save_styles:
+ save_text_styles()
+
+ def contextMenuEvent(self, e: QContextMenuEvent):
+ menu = QMenu()
+
+ new_act = menu.addAction(self.tr('New Text Style'))
+ removeall_act = menu.addAction(self.tr('Remove all'))
+ menu.addSeparator()
+ import_act = menu.addAction(self.tr('Import Text Styles'))
+ export_act = menu.addAction(self.tr('Export Text Styles'))
+
+ rst = menu.exec_(e.globalPos())
+
+ if rst == new_act:
+ self.on_newbtn_clicked()
+ elif rst == removeall_act:
+ self.on_clearbtn_clicked()
+ elif rst == import_act:
+ self.import_style.emit()
+ elif rst == export_act:
+ self.export_style.emit()
+
+ return super().contextMenuEvent(e)
diff --git a/ui/textedit_area.py b/ui/textedit_area.py
new file mode 100644
index 0000000000000000000000000000000000000000..cd4059045777fcec017a6af950e462015e111174
--- /dev/null
+++ b/ui/textedit_area.py
@@ -0,0 +1,791 @@
+from typing import List, Union
+
+from qtpy.QtWidgets import QStackedWidget, QSizePolicy, QTextEdit, QScrollArea, QGraphicsDropShadowEffect, QVBoxLayout, QApplication, QHBoxLayout, QSizePolicy, QLabel, QLineEdit
+from qtpy.QtCore import Signal, Qt, QMimeData, QEvent, QPoint, QSize
+from qtpy.QtGui import QIntValidator, QColor, QFocusEvent, QInputMethodEvent, QDragEnterEvent, QDropEvent, QKeyEvent, QTextCursor, QMouseEvent, QDrag, QPixmap, QKeySequence
+import keyboard
+import webbrowser
+import numpy as np
+
+from .custom_widget import ScrollBar, Widget, SeparatorWidget, ClickableLabel
+from .textitem import TextBlock
+from utils.config import pcfg
+from utils.logger import logger as LOGGER
+
+
+STYLE_TRANSPAIR_CHECKED = "background-color: rgba(30, 147, 229, 20%);"
+STYLE_TRANSPAIR_BOTTOM = "border-width: 5px; border-bottom-style: solid; border-color: rgb(30, 147, 229);"
+STYLE_TRANSPAIR_TOP = "border-width: 5px; border-top-style: solid; border-color: rgb(30, 147, 229);"
+
+
+class SelectTextMiniMenu(Widget):
+
+ block_current_editor = Signal(bool)
+
+ def __init__(self, app: QApplication, parent=None, *args, **kwargs) -> None:
+ super().__init__(parent=parent, *args, **kwargs)
+ self.app = app
+ self.search_internet_btn = ClickableLabel(parent=self)
+ self.search_internet_btn.setObjectName("SearchInternet")
+ self.search_internet_btn.setToolTip(self.tr("Search selected text on Internet"))
+ self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, True)
+ self.search_internet_btn.clicked.connect(self.on_search_internet)
+ self.saladict_btn = ClickableLabel(parent=self)
+ self.saladict_btn.setObjectName("SalaDict")
+ self.saladict_btn.clicked.connect(self.on_saladict)
+ self.saladict_btn.setToolTip(self.tr("Look up selected text in SalaDict, see installation guide in configpanel"))
+ layout = QHBoxLayout(self)
+ layout.addWidget(self.saladict_btn)
+ layout.addWidget(self.search_internet_btn)
+ layout.setContentsMargins(0, 0, 0, 0)
+ layout.setSpacing(0)
+
+ self.selected_text = ''
+
+ def on_search_internet(self):
+ browser = webbrowser.get()
+ browser.open_new(pcfg.search_url + self.selected_text)
+ self.hide()
+
+ def on_saladict(self):
+ self.app.clipboard().setText(self.selected_text)
+ self.block_current_editor.emit(True)
+ keyboard.press(pcfg.saladict_shortcut)
+ keyboard.release(pcfg.saladict_shortcut)
+ self.block_current_editor.emit(False)
+ self.hide()
+
+
+class SourceTextEdit(QTextEdit):
+ hover_enter = Signal(int)
+ hover_leave = Signal(int)
+ focus_in = Signal(int)
+ propagate_user_edited = Signal(int, str, bool)
+ ensure_scene_visible = Signal()
+ redo_signal = Signal()
+ undo_signal = Signal()
+ push_undo_stack = Signal(int)
+ text_changed = Signal()
+ show_select_menu = Signal(QPoint, str)
+ focus_out = Signal(int)
+
+ def __init__(self, idx, parent, fold=False, *args, **kwargs):
+ super().__init__(parent, *args, **kwargs)
+ self.idx = idx
+ self.pre_editing = False
+ self.setStyleSheet(r"QScrollBar:horizontal {height: 5px;}")
+ self.document().contentsChanged.connect(self.on_content_changed)
+ self.document().documentLayout().documentSizeChanged.connect(self.adjustSize)
+ self.document().contentsChange.connect(self.on_content_changing)
+ self.setAcceptRichText(False)
+ self.setAttribute(Qt.WidgetAttribute.WA_InputMethodEnabled, True)
+ self.old_undo_steps = self.document().availableUndoSteps()
+ self.in_redo_undo = False
+ self.change_from: int = 0
+ self.change_added: int = 0
+ self.input_method_from = -1
+ self.input_method_text = ''
+ self.text_content_changed = False
+ self.highlighting = False
+ self.paste_flag = False
+
+ self.selected_text = ''
+ self.cursorPositionChanged.connect(self.on_cursorpos_changed)
+
+ self.cursor_coord = None
+ self.block_all_input = False
+ self.in_acts = False
+
+ self.min_height = 45
+ self.setFold(fold)
+
+ def setFold(self, fold: bool):
+ if fold:
+ self.min_height = 35
+ self.setLineWrapMode(QTextEdit.LineWrapMode.NoWrap)
+ else:
+ self.min_height = 45
+ self.setLineWrapMode(QTextEdit.LineWrapMode.WidgetWidth)
+
+
+ def contextMenuEvent(self, event):
+ menu = self.createStandardContextMenu()
+ menu.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
+ acts = menu.actions()
+ self.in_acts = True
+ rst = menu.exec_(event.globalPos())
+
+ # future actions orders changes could break these comparsion
+ self.paste_flag = rst == acts[5]
+ if self.paste_flag or rst == acts[3] or rst == acts[6]:
+ self.handle_content_change()
+ self.in_acts = False
+
+ def on_cursorpos_changed(self) -> None:
+ cursor = self.textCursor()
+ if cursor.hasSelection():
+ self.selected_text = cursor.selectedText()
+ crect = self.cursorRect()
+ if cursor.selectionStart() == cursor.position():
+ self.cursor_coord = crect.bottomLeft()
+ else:
+ self.cursor_coord = crect.bottomRight()
+ else:
+ if self.cursor_coord is not None:
+ self.show_select_menu.emit(QPoint(), '')
+ self.cursor_coord = None
+
+ def mouseReleaseEvent(self, e: QMouseEvent) -> None:
+ super().mouseReleaseEvent(e)
+ if e.button() == Qt.MouseButton.LeftButton:
+ if self.hasFocus():
+ if self.cursor_coord is not None:
+ pos = self.mapToGlobal(self.cursor_coord)
+ sel_text = self.selected_text
+ self.show_select_menu.emit(pos, sel_text)
+
+ def block_all_signals(self, block: bool):
+ self.blockSignals(block)
+ self.document().blockSignals(block)
+
+ def updateUndoSteps(self):
+ self.old_undo_steps = self.document().availableUndoSteps()
+
+ def on_content_changing(self, from_: int, removed: int, added: int):
+ if not self.pre_editing:
+ self.text_content_changed = True
+ if self.hasFocus():
+ self.change_from = from_
+ self.change_added = added
+
+ def adjustSize(self):
+ h = self.document().documentLayout().documentSize().toSize().height()
+ self.setFixedHeight(max(h, self.min_height))
+
+ def on_content_changed(self):
+ if self.text_content_changed:
+ self.text_content_changed = False
+ if not self.highlighting:
+ self.text_changed.emit()
+
+ if self.hasFocus() and not self.pre_editing and not self.highlighting and not self.in_acts:
+ self.handle_content_change()
+
+ def handle_content_change(self):
+ if not self.in_redo_undo:
+
+ change_from = self.change_from
+ added_text = ''
+
+ if self.paste_flag:
+ self.paste_flag = False
+ cursor = self.textCursor()
+ cursor.setPosition(change_from)
+ cursor.setPosition(self.textCursor().position(), QTextCursor.MoveMode.KeepAnchor)
+ added_text = cursor.selectedText()
+
+ else:
+ if self.input_method_from != -1:
+ added_text = self.input_method_text
+ change_from = self.input_method_from
+ self.input_method_from = -1
+ elif self.change_added > 0:
+ cursor = self.textCursor()
+ cursor.setPosition(change_from)
+ cursor.setPosition(change_from + self.change_added, QTextCursor.MoveMode.KeepAnchor)
+ added_text = cursor.selectedText()
+
+ undo_steps = self.document().availableUndoSteps()
+ new_steps = undo_steps - self.old_undo_steps
+ joint_previous = new_steps == 0
+ self.propagate_user_edited.emit(change_from, added_text, joint_previous)
+ self.change_added = 0
+
+ if new_steps > 0:
+ self.old_undo_steps = undo_steps
+ self.push_undo_stack.emit(new_steps)
+
+ def setHoverEffect(self, hover: bool):
+ try:
+ if hover:
+ se = QGraphicsDropShadowEffect()
+ se.setBlurRadius(12)
+ se.setOffset(0, 0)
+ se.setColor(QColor(30, 147, 229))
+ self.setGraphicsEffect(se)
+ else:
+ self.setGraphicsEffect(None)
+ except RuntimeError:
+ pass
+
+ def enterEvent(self, event: QEvent) -> None:
+ self.setHoverEffect(True)
+ self.hover_enter.emit(self.idx)
+ return super().enterEvent(event)
+
+ def leaveEvent(self, event: QEvent) -> None:
+ self.setHoverEffect(False)
+ self.hover_leave.emit(self.idx)
+ return super().leaveEvent(event)
+
+ def focusInEvent(self, event: QFocusEvent) -> None:
+ self.setHoverEffect(True)
+ self.focus_in.emit(self.idx)
+ self.pre_editing = False
+ return super().focusInEvent(event)
+
+ def focusOutEvent(self, event: QFocusEvent) -> None:
+ self.setHoverEffect(False)
+ self.focus_out.emit(self.idx)
+ return super().focusOutEvent(event)
+
+ def inputMethodEvent(self, e: QInputMethodEvent) -> None:
+ if self.pre_editing is False:
+ cursor = self.textCursor()
+ self.input_method_from = cursor.selectionStart()
+ if e.preeditString() == '':
+ self.pre_editing = False
+ self.input_method_text = e.commitString()
+ else:
+ self.pre_editing = True
+ super().inputMethodEvent(e)
+
+ def keyPressEvent(self, e: QKeyEvent) -> None:
+ if self.block_all_input:
+ e.setAccepted(True)
+ return
+
+ if e.modifiers() == Qt.KeyboardModifier.ControlModifier:
+ if e.key() == Qt.Key.Key_Z:
+ e.accept()
+ self.undo_signal.emit()
+ return
+ elif e.key() == Qt.Key.Key_Y:
+ e.accept()
+ self.redo_signal.emit()
+ return
+ elif e.key() == Qt.Key.Key_V:
+ self.paste_flag = True
+ return super().keyPressEvent(e)
+ elif e.modifiers() == Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.ShiftModifier:
+ if e.key() == Qt.Key.Key_Z:
+ e.accept()
+ self.redo_signal.emit()
+ return
+ elif e.key() == Qt.Key.Key_Return:
+ e.accept()
+ self.textCursor().insertText('\n')
+ return
+ return super().keyPressEvent(e)
+
+ def undo(self) -> None:
+ self.in_redo_undo = True
+ self.document().undo()
+ self.in_redo_undo = False
+ self.old_undo_steps = self.document().availableUndoSteps()
+
+ def redo(self) -> None:
+ self.in_redo_undo = True
+ self.document().redo()
+ self.in_redo_undo = False
+ self.old_undo_steps = self.document().availableUndoSteps()
+
+ def setPlainTextAndKeepUndoStack(self, text: str):
+ cursor = QTextCursor(self.document())
+ cursor.select(QTextCursor.SelectionType.Document)
+ cursor.insertText(text)
+
+
+class TransTextEdit(SourceTextEdit):
+ pass
+
+
+class RowIndexEditor(QLineEdit):
+
+ focus_out = Signal()
+
+ def __init__(self, parent=None):
+ super().__init__(parent=parent)
+ self.setValidator(QIntValidator())
+ self.setReadOnly(True)
+ self.setTextMargins(0, 0, 0, 0)
+
+ def focusOutEvent(self, e: QFocusEvent) -> None:
+ super().focusOutEvent(e)
+ self.focus_out.emit()
+
+ def minimumSizeHint(self):
+ size = super().minimumSizeHint()
+ return QSize(1, size.height())
+
+ def sizeHint(self):
+ size = super().sizeHint()
+ return QSize(1, size.height())
+
+
+class RowIndexLabel(QStackedWidget):
+
+ submmit_idx = Signal(int)
+
+ def __init__(self, text: str = None, parent=None):
+ super().__init__(parent=parent)
+ self.lineedit = RowIndexEditor(parent=self)
+ self.lineedit.focus_out.connect(self.on_lineedit_focusout)
+
+ self.show_label = QLabel(self)
+ self.text = self.show_label.text
+
+ self.addWidget(self.show_label)
+ self.addWidget(self.lineedit)
+ self.setCurrentIndex(0)
+
+ if text is not None:
+ self.setText(text)
+ self.setSizePolicy(QSizePolicy.Policy.Maximum, QSizePolicy.Policy.Maximum)
+
+ def setText(self, text):
+ if isinstance(text, int):
+ text = str(text)
+ self.show_label.setText(text)
+ self.lineedit.setText(text)
+
+ def keyPressEvent(self, e: QKeyEvent) -> None:
+ super().keyPressEvent(e)
+
+ key = e.key()
+ if key == Qt.Key.Key_Return:
+ self.try_update_idx()
+
+ def try_update_idx(self):
+ idx_str = self.lineedit.text().strip()
+ if not idx_str:
+ return
+ if self.text() == idx_str:
+ return
+ try:
+ idx = int(idx_str)
+ self.lineedit.setReadOnly(True)
+ self.submmit_idx.emit(idx)
+
+ except Exception as e:
+ LOGGER.warning(f'Invalid index str: {idx}')
+
+ def mouseDoubleClickEvent(self, e: QMouseEvent) -> None:
+ self.startEdit()
+ return super().mouseDoubleClickEvent(e)
+
+ def startEdit(self) -> None:
+ self.setCurrentIndex(1)
+ self.lineedit.setReadOnly(False)
+ self.lineedit.setFocus()
+
+ def on_lineedit_focusout(self):
+ edited = not self.lineedit.isReadOnly()
+ self.lineedit.setReadOnly(True)
+ self.setCurrentIndex(0)
+ if edited:
+ self.try_update_idx()
+
+ def mousePressEvent(self, e: QMouseEvent) -> None:
+ e.ignore()
+ return super().mousePressEvent(e)
+
+
+class TransPairWidget(Widget):
+
+ check_state_changed = Signal(object, bool, bool)
+ drag_move = Signal(int)
+ idx_edited = Signal(int, int)
+ pw_drop = Signal()
+
+ def __init__(self, textblock: TextBlock = None, idx: int = None, fold: bool = False, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+ self.e_source = SourceTextEdit(idx, self, fold)
+ self.e_trans = TransTextEdit(idx, self, fold)
+ self.idx_label = RowIndexLabel(idx, self)
+ self.idx_label.setText(str(idx + 1).zfill(2)) # showed index start from 1!
+ self.submmit_idx = self.idx_label.submmit_idx.connect(self.on_idx_edited)
+ self.textblock = textblock
+ self.idx = idx
+ self.checked = False
+ vlayout = QVBoxLayout()
+ vlayout.setAlignment(Qt.AlignTop)
+ vlayout.addWidget(self.e_source)
+ vlayout.addWidget(self.e_trans)
+ vlayout.addWidget(SeparatorWidget(self))
+ spacing = 7
+ vlayout.setSpacing(spacing)
+ self.setCursor(Qt.CursorShape.PointingHandCursor)
+ self.setContentsMargins(0, 0, 0, 0)
+ vlayout.setContentsMargins(0, spacing, spacing, spacing)
+
+ hlayout = QHBoxLayout(self)
+ hlayout.addWidget(self.idx_label)
+ hlayout.addLayout(vlayout)
+ hlayout.setContentsMargins(0, 0, 0, 0)
+ hlayout.setSpacing(spacing)
+
+ self.setAcceptDrops(True)
+
+ def on_idx_edited(self, new_idx: int):
+ new_idx -= 1
+ self.idx_edited.emit(self.idx, new_idx)
+
+ def dragEnterEvent(self, e: QDragEnterEvent) -> None:
+ if isinstance(e.source(), TransPairWidget):
+ e.accept()
+ return super().dragEnterEvent(e)
+
+ def handle_drag(self, pos: QPoint):
+ y = pos.y()
+ to_pos = self.idx
+ if y > self.size().height() / 2:
+ to_pos += 1
+ self.drag_move.emit(to_pos)
+
+ def dragMoveEvent(self, e: QDragEnterEvent) -> None:
+ if isinstance(e.source(), TransPairWidget):
+ e.accept()
+ self.handle_drag(e.position())
+
+ return super().dragMoveEvent(e)
+
+ def dropEvent(self, e: QDropEvent) -> None:
+ if isinstance(e.source(), TransPairWidget):
+ e.acceptProposedAction()
+ self.pw_drop.emit()
+
+ def _set_checked_state(self, checked: bool):
+ """
+ this wont emit state_change signal and take care of the style
+ """
+ if self.checked != checked:
+ self.checked = checked
+ if checked:
+ self.setStyleSheet('TransPairWidget{' + f'{STYLE_TRANSPAIR_CHECKED}' + '}')
+ else:
+ self.setStyleSheet("")
+
+ def update_checkstate_by_mousevent(self, e: QMouseEvent):
+ if e.button() == Qt.MouseButton.LeftButton:
+ modifiers = e.modifiers()
+ if modifiers & Qt.KeyboardModifier.ShiftModifier and modifiers & Qt.KeyboardModifier.ControlModifier:
+ shift_pressed = ctrl_pressed = True
+ else:
+ shift_pressed = modifiers == Qt.KeyboardModifier.ShiftModifier
+ ctrl_pressed = modifiers == Qt.KeyboardModifier.ControlModifier
+ self.check_state_changed.emit(self, shift_pressed, ctrl_pressed)
+
+ def mousePressEvent(self, e: QMouseEvent) -> None:
+ if not self.checked:
+ self.update_checkstate_by_mousevent(e)
+ return super().mousePressEvent(e)
+
+ def updateIndex(self, idx: int):
+ if self.idx != idx:
+ self.idx = idx
+ self.idx_label.setText(str(idx + 1).zfill(2))
+ self.e_source.idx = idx
+ self.e_trans.idx = idx
+
+
+class TextEditListScrollArea(QScrollArea):
+
+ textblock_list: List[TextBlock] = []
+ pairwidget_list: List[TransPairWidget] = []
+ remove_textblock = Signal()
+ selection_changed = Signal() # this signal could only emit in on_widget_checkstate_changed, i.e. via user op
+ rearrange_blks = Signal(object)
+ textpanel_contextmenu_requested = Signal(QPoint, bool)
+ focus_out = Signal()
+
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+ self.scrollContent = Widget(parent=self)
+ self.setWidget(self.scrollContent)
+
+ # ScrollBar(Qt.Orientation.Horizontal, self)
+ ScrollBar(Qt.Orientation.Vertical, self)
+ self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+
+ vlayout = QVBoxLayout(self.scrollContent)
+ vlayout.setContentsMargins(0, 0, 3, 0)
+ vlayout.setAlignment(Qt.AlignmentFlag.AlignTop)
+ vlayout.setSpacing(0)
+ vlayout.addStretch(1)
+ self.setWidgetResizable(True)
+ self.vlayout = vlayout
+ self.checked_list: List[TransPairWidget] = []
+ self.sel_anchor_widget: TransPairWidget = None
+ self.drag: QDrag = None
+ self.dragStartPosition = None
+
+ self.source_visible = True
+ self.trans_visible = True
+
+ self.drag_to_pos: int = -1
+
+ self.setSizePolicy(self.sizePolicy().horizontalPolicy(), QSizePolicy.Policy.Expanding)
+ self.setContextMenuPolicy(Qt.ContextMenuPolicy.NoContextMenu)
+
+ def mouseReleaseEvent(self, e: QMouseEvent):
+ if e.button() == Qt.MouseButton.RightButton:
+ pos = self.mapToGlobal(e.position()).toPoint()
+ self.textpanel_contextmenu_requested.emit(pos, True)
+ super().mouseReleaseEvent(e)
+
+ def mousePressEvent(self, e: QMouseEvent) -> None:
+ if e.button() == Qt.MouseButton.LeftButton:
+ self.dragStartPosition = e.pos()
+ return super().mousePressEvent(e)
+
+ def mouseMoveEvent(self, e: QMouseEvent) -> None:
+ if self.drag is None and self.sel_anchor_widget is not None and self.dragStartPosition is not None:
+ if (e.pos() - self.dragStartPosition).manhattanLength() < QApplication.startDragDistance():
+ return
+ self.dragStartPosition = None
+ w = self.sel_anchor_widget
+ drag = self.drag = QDrag(w)
+ mime = QMimeData()
+ drag.setMimeData(mime)
+ pixmap = QPixmap(w.size())
+ w.render(pixmap)
+ drag.setPixmap(pixmap)
+ ac = drag.exec(Qt.DropAction.MoveAction)
+ self.drag = None
+ if self.drag_to_pos != -1:
+ self.set_drag_style(self.drag_to_pos, True)
+ self.drag_to_pos = -1
+ pass
+
+ return super().mouseMoveEvent(e)
+
+ def set_drag_style(self, pos: int, clear_style: bool = False):
+ if pos == len(self.pairwidget_list):
+ pos -= 1
+ style = STYLE_TRANSPAIR_BOTTOM
+ else:
+ style = STYLE_TRANSPAIR_TOP
+ if clear_style:
+ style = ""
+ pw = self.pairwidget_list[pos]
+ if pw.checked:
+ style += STYLE_TRANSPAIR_CHECKED
+ style = "TransPairWidget{" + style + "}"
+ pw.setStyleSheet(style)
+
+ def clearDrag(self):
+ self.drag_to_pos = -1
+ if self.drag is not None:
+ try:
+ self.drag.cancel()
+ except RuntimeError:
+ pass
+ self.drag = None
+
+ def handle_drag_pos(self, to_pos: int):
+ if self.drag_to_pos != to_pos:
+ if self.drag_to_pos is not None:
+ self.set_drag_style(self.drag_to_pos, True)
+ self.drag_to_pos = to_pos
+ self.set_drag_style(to_pos)
+
+ def on_pw_dropped(self):
+ if self.drag_to_pos != -1:
+ to_pos = self.drag_to_pos
+ self.drag_to_pos = -1
+ self.drag = None
+ self.set_drag_style(to_pos, True)
+ num_pw = len(self.pairwidget_list)
+ num_drags = len(self.checked_list)
+ if num_pw < 2 or num_drags == num_pw:
+ return
+
+ tgt_pos = to_pos
+ drags = []
+ for pw in self.checked_list:
+ if pw.idx < tgt_pos:
+ tgt_pos -= 1
+ drags.append(pw.idx)
+ new_pos = np.arange(num_drags, dtype=np.int32) + tgt_pos
+ drags = np.array(drags).astype(np.int32)
+ new_maps = np.where(drags != new_pos)
+ if len(new_maps) == 0:
+ return
+
+ drags_ori, drags_tgt = drags[new_maps], new_pos[new_maps]
+ result_list = list(range(len(self.pairwidget_list)))
+ to_insert = []
+ for ii, src_idx in enumerate(drags_ori):
+ pos = src_idx - ii
+ to_insert.append(result_list.pop(pos))
+ for ii, tgt_idx in enumerate(drags_tgt):
+ result_list.insert(tgt_idx, to_insert[ii])
+ drags_ori, drags_tgt = [], []
+ for ii, idx in enumerate(result_list):
+ if ii != idx:
+ drags_ori.append(idx)
+ drags_tgt.append(ii)
+
+ self.rearrange_blks.emit((drags_ori, drags_tgt))
+
+
+ def on_idx_edited(self, src_idx: int, tgt_idx: int):
+ src_idx_ori = tgt_idx
+ tgt_idx = max(min(tgt_idx, len(self.pairwidget_list) - 1), 0)
+ if src_idx_ori != tgt_idx:
+ self.pairwidget_list[src_idx].idx_label.setText(str(src_idx + 1).zfill(2))
+ if src_idx == tgt_idx:
+ return
+ ids_ori, ids_tgt = [src_idx], [tgt_idx]
+
+ if src_idx < tgt_idx:
+ for idx in range(src_idx+1, tgt_idx+1):
+ ids_ori.append(idx)
+ ids_tgt.append(idx-1)
+ else:
+ for idx in range(tgt_idx, src_idx):
+ ids_ori.append(idx)
+ ids_tgt.append(idx+1)
+ self.rearrange_blks.emit((ids_ori, ids_tgt, (tgt_idx, src_idx)))
+
+ def addPairWidget(self, pairwidget: TransPairWidget):
+ self.vlayout.insertWidget(pairwidget.idx, pairwidget)
+ pairwidget.check_state_changed.connect(self.on_widget_checkstate_changed)
+ pairwidget.e_trans.setVisible(self.trans_visible)
+ pairwidget.e_source.setVisible(self.source_visible)
+ pairwidget.setVisible(True)
+
+ def insertPairWidget(self, pairwidget: TransPairWidget, idx: int):
+ self.vlayout.insertWidget(idx, pairwidget)
+ pairwidget.e_trans.setVisible(self.trans_visible)
+ pairwidget.e_source.setVisible(self.source_visible)
+ pairwidget.setVisible(True)
+
+ def on_widget_checkstate_changed(self, pwc: TransPairWidget, shift_pressed: bool, ctrl_pressed: bool):
+ if self.drag is not None:
+ return
+
+ idx = pwc.idx
+ if shift_pressed:
+ checked = True
+ else:
+ checked = not pwc.checked
+ pwc._set_checked_state(checked)
+
+ num_sel = len(self.checked_list)
+ old_idx_list = [pw.idx for pw in self.checked_list]
+ old_idx_set = set(old_idx_list)
+ new_check_list = []
+ if shift_pressed:
+ if num_sel == 0:
+ new_check_list.append(idx)
+ else:
+ tgt_w = self.pairwidget_list[idx]
+ if ctrl_pressed:
+ sel_min, sel_max = min(old_idx_list[0], tgt_w.idx), max(old_idx_list[-1], tgt_w.idx)
+ else:
+ sel_min, sel_max = min(self.sel_anchor_widget.idx, tgt_w.idx), max(self.sel_anchor_widget.idx, tgt_w.idx)
+ new_check_list = list(range(sel_min, sel_max + 1))
+ elif ctrl_pressed:
+ new_check_set = set(old_idx_list)
+ if idx in new_check_set:
+ new_check_set.remove(idx)
+ if self.sel_anchor_widget is not None and self.sel_anchor_widget.idx == idx:
+ self.sel_anchor_widget = None
+ elif checked:
+ new_check_set.add(idx)
+ new_check_list = list(new_check_set)
+ new_check_list.sort()
+ if checked:
+ self.sel_anchor_widget = self.pairwidget_list[idx]
+ else:
+ if num_sel > 2:
+ if idx in old_idx_set:
+ old_idx_set.remove(idx)
+ checked = True
+ if checked:
+ new_check_list.append(idx)
+
+ new_check_set = set(new_check_list)
+ check_changed = False
+ for oidx in old_idx_set:
+ if oidx not in new_check_set:
+ self.pairwidget_list[oidx]._set_checked_state(False)
+ check_changed = True
+
+ self.checked_list.clear()
+ for nidx in new_check_list:
+ pw = self.pairwidget_list[nidx]
+ if nidx not in old_idx_set:
+ check_changed = True
+ pw._set_checked_state(True)
+ self.checked_list.append(pw)
+
+ num_new = len(new_check_list)
+ if num_new == 0:
+ self.sel_anchor_widget = None
+ elif num_new == 1 or self.sel_anchor_widget is None:
+ self.sel_anchor_widget = self.checked_list[0]
+ if check_changed:
+ self.selection_changed.emit()
+ if pwc.checked:
+ pwc.e_trans.focus_in.emit(pwc.idx)
+
+ def set_selected_list(self, selection_indices: List):
+ self.clearDrag()
+
+ old_sel_set, new_sel_set = set([pw.idx for pw in self.checked_list]), set(selection_indices)
+ to_remove = old_sel_set.difference(new_sel_set)
+ to_add = new_sel_set.difference(old_sel_set)
+ self.sel_anchor_widget = None
+
+ for idx in to_remove:
+ pw = self.pairwidget_list[idx]
+ pw._set_checked_state(False)
+ self.checked_list.remove(pw)
+
+ for ii, idx in enumerate(to_add):
+ pw = self.pairwidget_list[idx]
+ pw._set_checked_state(True)
+ self.checked_list.append(pw)
+ if ii == 0:
+ self.sel_anchor_widget = pw
+
+ def clearAllSelected(self, emit_signal=True):
+ self.sel_anchor_widget = None
+ if len(self.checked_list) > 0:
+ for w in self.checked_list:
+ w._set_checked_state(False)
+ self.checked_list.clear()
+ if emit_signal:
+ self.selection_changed.emit()
+
+ def removeWidget(self, widget: TransPairWidget, remove_checked: bool = True):
+ widget.setVisible(False)
+ if remove_checked:
+ if self.sel_anchor_widget is not None and self.sel_anchor_widget.idx == widget.idx:
+ self.sel_anchor_widget = None
+ if widget in self.checked_list:
+ widget._set_checked_state(False)
+ self.checked_list.remove(widget)
+ self.vlayout.removeWidget(widget)
+
+ def focusOutEvent(self, e: QFocusEvent) -> None:
+ self.focus_out.emit()
+ super().focusOutEvent(e)
+
+ def setFoldTextarea(self, fold: bool):
+ for pw in self.pairwidget_list:
+ pw.e_trans.setFold(fold)
+ pw.e_source.setFold(fold)
+
+ def setSourceVisible(self, show: bool):
+ self.source_visible = show
+ for pw in self.pairwidget_list:
+ pw.e_source.setVisible(show)
+
+ def setTransVisible(self, show: bool):
+ self.trans_visible = show
+ for pw in self.pairwidget_list:
+ pw.e_trans.setVisible(show)
\ No newline at end of file
diff --git a/ui/textedit_commands.py b/ui/textedit_commands.py
new file mode 100644
index 0000000000000000000000000000000000000000..71b9c274151b79fb713aea2f729fd4f5310ce60f
--- /dev/null
+++ b/ui/textedit_commands.py
@@ -0,0 +1,519 @@
+from typing import List, Union, Tuple
+
+from qtpy.QtGui import QTextCursor
+from qtpy.QtCore import QPointF
+try:
+ from qtpy.QtWidgets import QUndoCommand
+except:
+ from qtpy.QtGui import QUndoCommand
+
+from .textitem import TextBlkItem, TextBlock
+from .textedit_area import TransTextEdit, SourceTextEdit
+from utils.fontformat import FontFormat
+import utils.config as C
+from .misc import doc_replace, doc_replace_no_shift
+from .texteditshapecontrol import TextBlkShapeControl
+from .page_search_widget import PageSearchWidget, Matched
+from utils.proj_imgtrans import ProjImgTrans
+from .scene_textlayout import PUNSET_HALF
+
+
+def propagate_user_edit(src_edit: Union[TransTextEdit, TextBlkItem], target_edit: Union[TransTextEdit, TextBlkItem], pos: int, added_text: str, joint_previous: bool = False):
+ ori_count = target_edit.document().characterCount()
+ new_count = src_edit.document().characterCount()
+ removed = ori_count + len(added_text) - new_count
+
+ cursor = target_edit.textCursor()
+ cursor.setPosition(pos)
+ if joint_previous:
+ cursor.joinPreviousEditBlock()
+ else:
+ cursor.beginEditBlock()
+ if removed > 0:
+ cursor.setPosition(pos + removed, QTextCursor.MoveMode.KeepAnchor)
+ cursor.insertText(added_text)
+ cursor.endEditBlock()
+ target_edit.old_undo_steps = target_edit.document().availableUndoSteps()
+
+
+class MoveBlkItemsCommand(QUndoCommand):
+ def __init__(self, items: List[TextBlkItem], shape_ctrl: TextBlkShapeControl):
+ super(MoveBlkItemsCommand, self).__init__()
+ self.items = items
+ self.old_pos_lst: List[QPointF] = []
+ self.new_pos_lst: List[QPointF] = []
+ self.shape_ctrl = shape_ctrl
+ for item in items:
+ padding = item.padding()
+ padding = QPointF(padding, padding)
+ self.old_pos_lst.append(item.oldPos + padding)
+ self.new_pos_lst.append(item.pos() + padding)
+ item.oldPos = item.pos()
+
+ def redo(self):
+ for item, new_pos in zip(self.items, self.new_pos_lst):
+ padding = item.padding()
+ padding = QPointF(padding, padding)
+ item.setPos(new_pos - padding)
+ if self.shape_ctrl.blk_item == item and self.shape_ctrl.pos() != new_pos:
+ self.shape_ctrl.setPos(new_pos)
+
+ def undo(self):
+ for item, old_pos in zip(self.items, self.old_pos_lst):
+ padding = item.padding()
+ padding = QPointF(padding, padding)
+ item.setPos(old_pos - padding)
+ if self.shape_ctrl.blk_item == item and self.shape_ctrl.pos() != old_pos:
+ self.shape_ctrl.setPos(old_pos)
+
+
+class ApplyFontformatCommand(QUndoCommand):
+ def __init__(self, items: List[TextBlkItem], trans_widget_lst: List[TransTextEdit], fontformat: FontFormat):
+ super(ApplyFontformatCommand, self).__init__()
+ self.items = items
+ self.old_html_lst = []
+ self.old_rect_lst = []
+ self.old_fmt_lst = []
+ self.new_fmt = fontformat
+ self.trans_widget_lst = trans_widget_lst
+ for item in items:
+ self.old_html_lst.append(item.toHtml())
+ self.old_fmt_lst.append(item.get_fontformat())
+ self.old_rect_lst.append(item.absBoundingRect(qrect=True))
+
+ def redo(self):
+ for item, edit in zip(self.items, self.trans_widget_lst):
+ item.set_fontformat(self.new_fmt, set_char_format=True)
+ edit.document().clearUndoRedoStacks()
+
+ def undo(self):
+ for rect, item, html, fmt, edit in zip(self.old_rect_lst, self.items, self.old_html_lst, self.old_fmt_lst, self.trans_widget_lst):
+ item.setHtml(html)
+ item.set_fontformat(fmt)
+ item.setRect(rect)
+ edit.document().clearUndoRedoStacks()
+
+
+class ReshapeItemCommand(QUndoCommand):
+ def __init__(self, item: TextBlkItem):
+ super(ReshapeItemCommand, self).__init__()
+ self.item = item
+ self.oldRect = item.oldRect
+ self.newRect = item.absBoundingRect(qrect=True)
+ self.idx = -1
+
+ def redo(self):
+ if self.idx < 0:
+ self.idx += 1
+ return
+ self.item.setRect(self.newRect)
+
+ def undo(self):
+ self.item.setRect(self.oldRect)
+
+ def mergeWith(self, command: QUndoCommand):
+ item = command.item
+ if self.item != item:
+ return False
+ self.newRect = item.rect()
+ return True
+
+
+class RotateItemCommand(QUndoCommand):
+ def __init__(self, item: TextBlkItem, new_angle: float, shape_ctrl: TextBlkShapeControl):
+ super(RotateItemCommand, self).__init__()
+ self.item = item
+ self.old_angle = item.rotation()
+ self.new_angle = new_angle
+ self.shape_ctrl = shape_ctrl
+
+ def redo(self):
+ self.item.setRotation(self.new_angle)
+ self.item.blk.angle = self.new_angle
+ if self.shape_ctrl.blk_item == self.item and self.shape_ctrl.rotation() != self.new_angle:
+ self.shape_ctrl.setRotation(self.new_angle)
+
+ def undo(self):
+ self.item.setRotation(self.old_angle)
+ self.item.blk.angle = self.old_angle
+ if self.shape_ctrl.blk_item == self.item and self.shape_ctrl.rotation() != self.old_angle:
+ self.shape_ctrl.setRotation(self.old_angle)
+
+ def mergeWith(self, command: QUndoCommand):
+ item = command.item
+ if self.item != item:
+ return False
+ self.new_angle = item.angle
+ return True
+
+
+class AutoLayoutCommand(QUndoCommand):
+ def __init__(self, items: List[TextBlkItem], old_rect_lst: List, old_html_lst: List, trans_widget_lst: List[TransTextEdit]):
+ super(AutoLayoutCommand, self).__init__()
+ self.items = items
+ self.old_html_lst = old_html_lst
+ self.old_rect_lst = old_rect_lst
+ self.trans_widget_lst = trans_widget_lst
+ self.new_rect_lst = []
+ self.new_html_lst = []
+ for item in items:
+ self.new_html_lst.append(item.toHtml())
+ self.new_rect_lst.append(item.absBoundingRect(qrect=True))
+ self.counter = 0
+
+ def redo(self):
+ self.counter += 1
+ if self.counter <= 1:
+ return
+ for item, trans_widget, html, rect in zip(self.items, self.trans_widget_lst, self.new_html_lst, self.new_rect_lst):
+ trans_widget.setPlainText(item.toPlainText())
+ item.setPlainText('')
+ item.setRect(rect, repaint=False)
+ item.setHtml(html)
+ if item.fontformat.letter_spacing != 1:
+ item.setLetterSpacing(item.fontformat.letter_spacing, force=True)
+
+ def undo(self):
+ for item, trans_widget, html, rect in zip(self.items, self.trans_widget_lst, self.old_html_lst, self.old_rect_lst):
+ trans_widget.setPlainText(item.toPlainText())
+ item.setPlainText('')
+ item.setRect(rect, repaint=False)
+ item.setHtml(html)
+ if item.fontformat.letter_spacing != 1:
+ item.setLetterSpacing(item.fontformat.letter_spacing, force=True)
+
+
+class SqueezeCommand(QUndoCommand):
+ def __init__(self, blkitem_lst: List[TextBlkItem], ctrl: TextBlkShapeControl):
+ super(SqueezeCommand, self).__init__()
+ self.blkitem_lst = blkitem_lst
+ self.old_rect_lst = []
+ self.ctrl = ctrl
+ for item in blkitem_lst:
+ self.old_rect_lst.append(item.absBoundingRect(qrect=True))
+
+ def redo(self):
+ for blk in self.blkitem_lst:
+ blk.squeezeBoundingRect()
+
+ def undo(self):
+ for blk, rect in zip(self.blkitem_lst, self.old_rect_lst):
+ blk.setRect(rect, repaint=True)
+ if blk.under_ctrl:
+ self.ctrl.updateBoundingRect()
+
+class ResetAngleCommand(QUndoCommand):
+ def __init__(self, blkitem_lst: List[TextBlkItem], ctrl: TextBlkShapeControl):
+ super(ResetAngleCommand, self).__init__()
+ self.blkitem_lst = blkitem_lst
+ self.angle_lst = []
+ self.ctrl = ctrl
+ blkitem_lst = []
+ for blk in self.blkitem_lst:
+ rotation = blk.rotation()
+ if rotation != 0:
+ self.angle_lst.append(rotation)
+ blkitem_lst.append(blk)
+ self.blkitem_lst = blkitem_lst
+
+ def redo(self):
+ for blk in self.blkitem_lst:
+ blk.setAngle(0)
+ if self.ctrl.blk_item == blk:
+ self.ctrl.setAngle(0)
+
+ def undo(self):
+ for blk, angle in zip(self.blkitem_lst, self.angle_lst):
+ blk.setAngle(angle)
+ if self.ctrl.blk_item == blk:
+ self.ctrl.setAngle(angle)
+
+class TextItemEditCommand(QUndoCommand):
+ def __init__(self, blkitem: TextBlkItem, trans_edit: TransTextEdit, num_steps: int, formatpanel=None):
+ super(TextItemEditCommand, self).__init__()
+ self.op_counter = 0
+ self.edit = trans_edit
+ self.blkitem = blkitem
+ self.num_steps = num_steps
+ self.is_formatting = blkitem.is_formatting
+ self.old_ffmt_values = self.new_ffmt_values = None
+ if blkitem.is_formatting and blkitem.old_ffmt_values is not None:
+ self.old_ffmt_values = blkitem.old_ffmt_values.copy()
+ self.new_ffmt_values = self.old_ffmt_values.copy()
+ for k in self.new_ffmt_values:
+ self.new_ffmt_values[k] = getattr(blkitem.fontformat, k)
+ self.formatpanel = formatpanel
+
+ def redo(self):
+ if self.op_counter == 0:
+ self.op_counter += 1
+ return
+
+ self.blkitem.repaint_on_changed = False
+ if self.new_ffmt_values is not None:
+ for k, v in self.new_ffmt_values.items():
+ self.blkitem.fontformat[k] = v
+ self.blkitem.redo()
+ self.blkitem.repaint_on_changed = True
+ if self.num_steps > 0:
+ self.blkitem.repaint_background()
+
+ if self.is_formatting and self.blkitem == self.formatpanel.textblk_item:
+ multi_size = not self.blkitem.isEditing() and self.blkitem.isMultiFontSize()
+ self.formatpanel.set_active_format(self.blkitem.get_fontformat(), multi_size)
+
+ if self.edit is not None and not self.is_formatting:
+ self.edit.redo()
+
+ def undo(self):
+ self.blkitem.repaint_on_changed = False
+ if self.old_ffmt_values is not None:
+ for k, v in self.old_ffmt_values.items():
+ self.blkitem.fontformat[k] = v
+ self.blkitem.undo()
+ self.blkitem.repaint_on_changed = True
+ if self.num_steps > 0:
+ self.blkitem.repaint_background()
+
+ if self.is_formatting and self.blkitem == self.formatpanel.textblk_item:
+ multi_size = not self.blkitem.isEditing() and self.blkitem.isMultiFontSize()
+ self.formatpanel.set_active_format(self.blkitem.get_fontformat(), multi_size)
+
+ if self.edit is not None:
+ self.edit.undo()
+
+
+class TextEditCommand(QUndoCommand):
+ def __init__(self, edit: Union[SourceTextEdit, TransTextEdit], num_steps: int, blkitem: TextBlkItem) -> None:
+ super().__init__()
+ # TODO: remove it for transtextedit
+ self.edit = edit
+ self.blkitem = blkitem
+ self.op_counter = 0
+ self.num_steps = num_steps
+
+ def redo(self):
+ if self.op_counter == 0:
+ self.op_counter += 1
+ return
+ self.edit.redo()
+ if self.blkitem is not None:
+ self.blkitem.redo()
+
+ def undo(self):
+ self.edit.undo()
+ if self.blkitem is not None:
+ self.blkitem.undo()
+
+
+class PageReplaceOneCommand(QUndoCommand):
+ def __init__(self, se: PageSearchWidget, parent=None):
+ super(PageReplaceOneCommand, self).__init__(parent)
+ self.op_counter = 0
+ self.sw = se
+ self.reptxt = self.sw.replace_editor.toPlainText()
+ self.repl_len = len(self.reptxt)
+
+ self.sel_start = self.sw.current_cursor.selectionStart()
+ self.oritxt = self.sw.current_cursor.selectedText()
+ self.ori_len = len(self.oritxt)
+ self.edit: Union[SourceTextEdit, TransTextEdit] = self.sw.current_edit
+ self.edit_is_src = type(self.edit) == SourceTextEdit
+ self.blkitem = self.sw.textblk_item_list[self.sw.current_edit.idx]
+
+ if self.sw.current_edit is not None and self.sw.isVisible():
+ move = self.sw.move_cursor(1)
+ if move == 0:
+ self.sw.result_pos = min(self.sw.counter_sum - 1, self.sw.result_pos + 1)
+ else:
+ self.sw.result_pos = 0
+
+ if not self.edit_is_src:
+ cursor = self.blkitem.textCursor()
+ cursor.setPosition(self.sel_start)
+ cursor.setPosition(self.sel_start+self.ori_len, QTextCursor.MoveMode.KeepAnchor)
+ cursor.beginEditBlock()
+ cursor.insertText(self.reptxt)
+ cursor.endEditBlock()
+
+ self.rep_cursor = self.edit.textCursor()
+ self.rep_cursor.setPosition(self.sel_start)
+ self.rep_cursor.setPosition(self.sel_start+self.ori_len, QTextCursor.MoveMode.KeepAnchor)
+ self.rep_cursor.insertText(self.reptxt)
+ self.edit.updateUndoSteps()
+
+ def redo(self):
+ if self.op_counter == 0:
+ self.op_counter += 1
+ return
+
+ if self.sw.current_edit is not None and self.sw.isVisible():
+ move = self.sw.move_cursor(1)
+ if move == 0:
+ self.sw.result_pos = min(self.sw.counter_sum - 1, self.sw.result_pos + 1)
+ else:
+ self.sw.result_pos = 0
+
+ if not self.edit_is_src:
+ self.blkitem.redo()
+ self.edit.redo()
+
+ def undo(self):
+ if not self.edit_is_src:
+ self.blkitem.undo()
+ self.sw.update_cursor_on_insert = False
+ self.edit.undo()
+ self.sw.update_cursor_on_insert = True
+ if self.sw.current_edit is not None and self.sw.isVisible():
+ move = self.sw.move_cursor(-1)
+ if move == 0:
+ self.sw.result_pos = max(self.sw.result_pos - 1, 0)
+ else:
+ self.sw.result_pos = self.sw.counter_sum - 1
+ self.sw.updateCounterText()
+
+
+class PageReplaceAllCommand(QUndoCommand):
+
+ def __init__(self, search_widget: PageSearchWidget) -> None:
+ super().__init__()
+ self.op_counter = 0
+ self.sw = search_widget
+
+ self.rstedit_list: List[SourceTextEdit] = []
+ self.blkitem_list: List[TextBlkItem] = []
+ curpos_list: List[List[Matched]] = []
+ for edit, highlighter in zip(self.sw.search_rstedit_list, self.sw.highlighter_list):
+ self.rstedit_list.append(edit)
+ curpos_list.append(list(highlighter.matched_map.values()))
+
+ replace = self.sw.replace_editor.toPlainText()
+ for edit, curpos_lst in zip(self.rstedit_list, curpos_list):
+ redo_blk = type(edit) == TransTextEdit
+ if redo_blk:
+ blkitem = self.sw.textblk_item_list[edit.idx]
+ self.blkitem_list.append(blkitem)
+ span_list = [[matched.start, matched.end] for matched in curpos_lst]
+ sel_list = doc_replace(edit.document(), span_list, replace)
+ if redo_blk:
+ doc_replace_no_shift(blkitem.document(), sel_list, replace)
+ blkitem.updateUndoSteps()
+
+ def redo(self):
+ if self.op_counter == 0:
+ self.op_counter += 1
+ return
+
+ for edit in self.rstedit_list:
+ edit.redo()
+ for blkitem in self.blkitem_list:
+ blkitem.redo()
+
+ def undo(self):
+ for edit in self.rstedit_list:
+ edit.undo()
+ for blkitem in self.blkitem_list:
+ blkitem.undo()
+
+
+class GlobalRepalceAllCommand(QUndoCommand):
+ def __init__(self, sceneitem_list: dict, background_list: dict, target_text: str, proj: ProjImgTrans) -> None:
+ super().__init__()
+ self.op_counter = -1
+ self.target_text = target_text
+ self.proj = proj
+ self.trans_list = sceneitem_list['trans']
+ self.src_list = sceneitem_list['src']
+ self.btrans_list = background_list['trans']
+ self.bsrc_list = background_list['src']
+
+ for trans_dict in self.trans_list:
+ edit: TransTextEdit = trans_dict['edit']
+ item: TextBlkItem = trans_dict['item']
+ matched_map = trans_dict['matched_map']
+ sel_list = doc_replace(edit.document(), matched_map, target_text)
+
+ doc_replace_no_shift(item.document(), sel_list, target_text)
+ item.updateUndoSteps()
+ item.updateUndoSteps()
+
+ trans_dict.pop('matched_map')
+
+ for src_dict in self.src_list:
+ edit: SourceTextEdit = src_dict['edit']
+ edit.setPlainTextAndKeepUndoStack(src_dict['replace'])
+ edit.updateUndoSteps()
+ src_dict.pop('replace')
+
+ def redo(self):
+ if self.op_counter == 0:
+ self.op_counter += 1
+ return
+
+ for trans_dict in self.trans_list:
+ edit: TransTextEdit = trans_dict['edit']
+ item: TextBlkItem = trans_dict['item']
+ edit.redo()
+ item.redo()
+
+ for src_dict in self.src_list:
+ edit: SourceTextEdit = src_dict['edit']
+ edit.redo()
+
+ for trans_dict in self.btrans_list:
+ blk: TextBlock = self.proj.pages[trans_dict['pagename']][trans_dict['idx']]
+ blk.translation = trans_dict['replace']
+ blk.rich_text = trans_dict['replace_html']
+
+ for src_dict in self.bsrc_list:
+ blk: TextBlock = self.proj.pages[src_dict['pagename']][src_dict['idx']]
+ blk.text = src_dict['replace']
+
+ def undo(self):
+ for trans_dict in self.trans_list:
+ edit: TransTextEdit = trans_dict['edit']
+ item: TextBlkItem = trans_dict['item']
+ edit.undo()
+ item.undo()
+
+ for src_dict in self.src_list:
+ edit: SourceTextEdit = src_dict['edit']
+ edit.undo()
+
+ for trans_dict in self.btrans_list:
+ blk: TextBlock = self.proj.pages[trans_dict['pagename']][trans_dict['idx']]
+ blk.translation = trans_dict['ori']
+ blk.rich_text = trans_dict['ori_html']
+
+ for src_dict in self.src_list:
+ blk: TextBlock = self.proj.pages[src_dict['pagename']][src_dict['idx']]
+ blk.text = src_dict['ori']
+
+
+class MultiPasteCommand(QUndoCommand):
+ def __init__(self, text_list: Union[str, List], blkitems: List[TextBlkItem], etrans: List[TransTextEdit]) -> None:
+ super().__init__()
+ self.op_counter = -1
+ self.blkitems = blkitems
+ self.etrans = etrans
+
+ if len(blkitems) > 0:
+ if isinstance(text_list, str):
+ text_list = [text_list] * len(blkitems)
+
+ for blkitem, etran, text in zip(self.blkitems, self.etrans, text_list):
+ etran.setPlainTextAndKeepUndoStack(text)
+ blkitem.setPlainTextAndKeepUndoStack(text)
+
+ def redo(self):
+ if self.op_counter == 0:
+ self.op_counter += 1
+ return
+ for blkitem, etran in zip(self.blkitems, self.etrans):
+ blkitem.redo()
+ etran.redo()
+
+ def undo(self):
+ for blkitem, etran in zip(self.blkitems, self.etrans):
+ blkitem.undo()
+ etran.undo()
\ No newline at end of file
diff --git a/ui/texteditshapecontrol.py b/ui/texteditshapecontrol.py
new file mode 100644
index 0000000000000000000000000000000000000000..b36d55cefe7d97bf7cb7549a953362959c9b9542
--- /dev/null
+++ b/ui/texteditshapecontrol.py
@@ -0,0 +1,351 @@
+import math
+from functools import cached_property
+
+import numpy as np
+from qtpy.QtWidgets import QGraphicsPixmapItem, QGraphicsItem, QWidget, QGraphicsSceneHoverEvent, QLabel, QStyleOptionGraphicsItem, QGraphicsSceneMouseEvent, QGraphicsRectItem
+from qtpy.QtCore import Qt, QRect, QRectF, QPointF, QPoint
+from qtpy.QtGui import QPainter, QPen, QColor
+
+from utils.imgproc_utils import xywh2xyxypoly, rotate_polygons
+from .cursor import rotateCursorList, resizeCursorList
+from .textitem import TextBlkItem
+
+CBEDGE_WIDTH = 30
+
+VISUALIZE_HITBOX = False
+ctrlidx_to_hitbox = {
+ 0: [-0.75, -0.75, 0.75, 0.75],
+ 1: [-0.5, -0.75, 1, 0.75],
+ 2: [0., -0.75, 0.75, 0.75],
+ 3: [0., -0.5, 0.75, 1],
+ 4: [0., 0., 0.75, 0.75],
+ 5: [-0.5, 0., 1, 0.75],
+ 6: [-0.75, 0., 0.75, 0.75],
+ 7: [-0.75, -0.5, 0.75, 1]
+}
+for k, v in ctrlidx_to_hitbox.items():
+ ctrlidx_to_hitbox[k] = np.array(v, dtype=np.float32)
+
+ctrlidx_to_visiblebox = {
+ 0: [0.25, 0.25, 0.75, 0.75],
+ 1: [0.25, 0.25, 0.75],
+ 2: [0., 0.25, 0.75, 0.75],
+ 3: [0., 0.25, 0.75, 1],
+ 4: [0., 0., 0.75, 0.75],
+ 5: [0.25, 0., 1, 0.75],
+ 6: [0.25, 0., 0.75, 0.75],
+ 7: [0.25, 0.25, 0.75, 1]
+}
+for k, v in ctrlidx_to_visiblebox.items():
+ ctrlidx_to_visiblebox[k] = np.array(v, dtype=np.float32)
+
+class ControlBlockItem(QGraphicsRectItem):
+ DRAG_NONE = 0
+ DRAG_RESHAPE = 1
+ DRAG_ROTATE = 2
+ CURSOR_IDX = -1
+ def __init__(self, parent, idx: int):
+ super().__init__(parent)
+ self.idx = idx
+ self.ctrl: TextBlkShapeControl = parent
+ self.edge_width = 0
+ self.drag_mode = self.DRAG_NONE
+ self.setAcceptHoverEvents(True)
+ self.setFlags(QGraphicsItem.GraphicsItemFlag.ItemIsMovable | QGraphicsItem.GraphicsItemFlag.ItemIsSelectable)
+ self.updateEdgeWidth(CBEDGE_WIDTH)
+
+ def updateEdgeWidth(self, edge_width: float):
+ self.edge_width = edge_width
+ self.visible_len = self.edge_width / 2
+ self.block_shift_value = self.edge_width * 0.75
+ self.pen_width = edge_width / CBEDGE_WIDTH * 2
+ offset = self.edge_width * ctrlidx_to_visiblebox[self.idx]
+ self.visible_rect = QRectF(offset[0], offset[1], self.visible_len, self.visible_len)
+ hitbox = ctrlidx_to_hitbox[self.idx]
+ w = hitbox[2] * self.edge_width
+ h = hitbox[3] * self.edge_width
+ self.setRect(0, 0, w, h)
+
+ def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, widget: QWidget) -> None:
+ rect = QRectF(self.visible_rect)
+ rect.setTopLeft(self.boundingRect().topLeft()+rect.topLeft())
+ painter.setPen(QPen(QColor(75, 75, 75), self.pen_width, Qt.PenStyle.SolidLine, Qt.SquareCap))
+ painter.fillRect(rect, QColor(200, 200, 200, 125))
+ painter.drawRect(rect)
+ if VISUALIZE_HITBOX:
+ painter.setPen(QPen(QColor(75, 125, 0), self.pen_width, Qt.PenStyle.SolidLine, Qt.SquareCap))
+ painter.drawRect(self.boundingRect())
+
+ def hoverEnterEvent(self, event: QGraphicsSceneHoverEvent) -> None:
+ return super().hoverEnterEvent(event)
+
+ def hoverLeaveEvent(self, event: QGraphicsSceneHoverEvent) -> None:
+ self.drag_mode = self.DRAG_NONE
+ self.CURSOR_IDX = -1
+ return super().hoverLeaveEvent(event)
+
+ def hoverMoveEvent(self, event: QGraphicsSceneHoverEvent) -> None:
+ angle = self.ctrl.rotation() + 45 * self.idx
+ idx = self.get_angle_idx(angle)
+ if self.visible_rect.contains(event.pos()):
+ self.setCursor(resizeCursorList[idx % 4])
+ else:
+ self.setCursor(rotateCursorList[idx])
+ self.CURSOR_IDX = idx
+ return super().hoverMoveEvent(event)
+
+ def hoverLeaveEvent(self, event: 'QGraphicsSceneHoverEvent') -> None:
+ if self.drag_mode == self.DRAG_NONE:
+ self.setCursor(Qt.CursorShape.SizeAllCursor)
+ return super().hoverLeaveEvent(event)
+
+ def mousePressEvent(self, event: QGraphicsSceneMouseEvent) -> None:
+ self.ctrl.ctrlblockPressed()
+ if event.button() == Qt.MouseButton.LeftButton and self.ctrl.blk_item is not None:
+ blk_item = self.ctrl.blk_item
+ blk_item.setSelected(True)
+ if self.visible_rect.contains(event.pos()):
+ self.ctrl.reshaping = True
+ self.drag_mode = self.DRAG_RESHAPE
+ self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsMovable, True)
+ blk_item.startReshape()
+ else:
+ self.drag_mode = self.DRAG_ROTATE
+ self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
+ preview = self.ctrl.previewPixmap
+
+ preview.setPixmap(blk_item.toPixmap().copy(blk_item.unpadRect(blk_item.boundingRect()).toRect()))
+ preview.setOpacity(0.7)
+ preview.setVisible(True)
+ rotate_vec = event.scenePos() - self.ctrl.sceneBoundingRect().center()
+ self.updateAngleLabelPos()
+ rotation = np.rad2deg(math.atan2(rotate_vec.y(), rotate_vec.x()))
+ self.rotate_start = - rotation + self.ctrl.rotation()
+ event.accept()
+
+ def updateAngleLabelPos(self):
+ angleLabel = self.ctrl.angleLabel
+ sp = self.scenePos()
+ gv = angleLabel.parent()
+ pos = gv.mapFromScene(sp)
+ x = max(min(pos.x(), gv.width() - angleLabel.width()), 0)
+ y = max(min(pos.y(), gv.height() - angleLabel.height()), 0)
+ angleLabel.move(QPoint(x, y))
+ angleLabel.setText("{:.1f}°".format(self.ctrl.rotation()))
+ if not angleLabel.isVisible():
+ angleLabel.setVisible(True)
+ angleLabel.raise_()
+
+ def mouseMoveEvent(self, event: QGraphicsSceneMouseEvent) -> None:
+ super().mouseMoveEvent(event)
+ blk_item = self.ctrl.blk_item
+ if blk_item is None:
+ return
+ if self.drag_mode == self.DRAG_RESHAPE:
+ block_group = self.ctrl.ctrlblock_group
+ crect = self.ctrl.rect()
+ pos_x, pos_y = 0, 0
+ opposite_block = block_group[(self.idx + 4) % 8 ]
+ oppo_pos = opposite_block.pos()
+ if self.idx % 2 == 0:
+ if self.idx == 0:
+ pos_x = min(self.pos().x(), oppo_pos.x())
+ pos_y = min(self.pos().y(), oppo_pos.y())
+ crect.setX(pos_x + self.block_shift_value)
+ crect.setY(pos_y + self.block_shift_value)
+ elif self.idx == 2:
+ pos_x = max(self.pos().x(), oppo_pos.x())
+ pos_y = min(self.pos().y(), oppo_pos.y())
+ crect.setWidth(pos_x - oppo_pos.x() - self.block_shift_value)
+ crect.setY(pos_y+self.block_shift_value)
+ elif self.idx == 4:
+ pos_x = max(self.pos().x(), oppo_pos.x())
+ pos_y = max(self.pos().y(), oppo_pos.y())
+ crect.setWidth(pos_x-oppo_pos.x() - self.block_shift_value)
+ crect.setHeight(pos_y-oppo_pos.y() - self.block_shift_value)
+ else: # idx == 6
+ pos_x = min(self.pos().x(), oppo_pos.x())
+ pos_y = max(self.pos().y(), oppo_pos.y())
+ crect.setX(pos_x+self.block_shift_value)
+ crect.setHeight(pos_y-oppo_pos.y() - self.block_shift_value)
+ else:
+ if self.idx == 1:
+ pos_y = min(self.pos().y(), oppo_pos.y())
+ crect.setY(pos_y+self.block_shift_value)
+ elif self.idx == 3:
+ pos_x = max(self.pos().x(), oppo_pos.x())
+ crect.setWidth(pos_x-oppo_pos.x() - self.block_shift_value)
+ elif self.idx == 5:
+ pos_y = max(self.pos().y(), oppo_pos.y())
+ crect.setHeight(pos_y-oppo_pos.y() - self.block_shift_value)
+ else: # idx == 7
+ pos_x = min(self.pos().x(), oppo_pos.x())
+ crect.setX(pos_x+self.block_shift_value)
+
+ self.ctrl.setRect(crect)
+ scale = self.ctrl.current_scale
+ new_center = self.ctrl.sceneBoundingRect().center()
+ new_xy = QPointF(new_center.x() / scale - crect.width() / 2, new_center.y() / scale - crect.height() / 2)
+ rect = QRectF(new_xy.x(), new_xy.y(), crect.width(), crect.height())
+ blk_item.setRect(rect)
+
+ elif self.drag_mode == self.DRAG_ROTATE: # rotating
+ rotate_vec = event.scenePos() - self.ctrl.sceneBoundingRect().center()
+ rotation = np.rad2deg(math.atan2(rotate_vec.y(), rotate_vec.x()))
+ self.ctrl.setAngle((rotation+self.rotate_start))
+ # angle = self.ctrl.rotation()
+ angle = self.ctrl.rotation() + 45 * self.idx
+ idx = self.get_angle_idx(angle)
+ if self.CURSOR_IDX != idx:
+ self.setCursor(rotateCursorList[idx])
+ self.CURSOR_IDX = idx
+ self.updateAngleLabelPos()
+
+ def get_angle_idx(self, angle) -> int:
+ idx = int((angle + 22.5) % 360 / 45)
+ return idx
+
+ def mouseReleaseEvent(self, event: QGraphicsSceneMouseEvent) -> None:
+ if event.button() == Qt.MouseButton.LeftButton:
+ self.ctrl.reshaping = False
+ if self.drag_mode == self.DRAG_RESHAPE:
+ self.ctrl.blk_item.endReshape()
+ if self.drag_mode == self.DRAG_ROTATE:
+ self.ctrl.blk_item.rotated.emit(self.ctrl.rotation())
+ self.drag_mode = self.DRAG_NONE
+
+ self.ctrl.previewPixmap.setVisible(False)
+ self.ctrl.angleLabel.setVisible(False)
+ self.ctrl.blk_item.update()
+ self.ctrl.updateBoundingRect()
+ return super().mouseReleaseEvent(event)
+
+class TextBlkShapeControl(QGraphicsRectItem):
+ blk_item : TextBlkItem = None
+ ctrl_block: ControlBlockItem = None
+ reshaping: bool = False
+
+ def __init__(self, parent) -> None:
+ super().__init__()
+ self.gv = parent
+ self.ctrlblock_group = [
+ ControlBlockItem(self, idx) for idx in range(8)
+ ]
+
+ self.previewPixmap = QGraphicsPixmapItem(self)
+ self.previewPixmap.setVisible(False)
+ pen = QPen(QColor(69, 71, 87), 2, Qt.PenStyle.SolidLine)
+ pen.setDashPattern([7, 14])
+ self.setPen(pen)
+ self.setVisible(False)
+
+ self.angleLabel = QLabel(parent)
+ self.angleLabel.setText("{:.1f}°".format(self.rotation()))
+ self.angleLabel.setObjectName("angleLabel")
+ self.angleLabel.setAlignment(Qt.AlignmentFlag.AlignCenter)
+ self.angleLabel.setHidden(True)
+
+ self.current_scale = 1.
+ self.need_rescale = False
+ self.setCursor(Qt.CursorShape.SizeAllCursor)
+
+ def setBlkItem(self, blk_item: TextBlkItem):
+ if self.blk_item == blk_item and self.isVisible():
+ return
+ if self.blk_item is not None:
+ self.blk_item.under_ctrl = False
+ if self.blk_item.isEditing():
+ self.blk_item.endEdit()
+ self.blk_item.update()
+
+ self.blk_item = blk_item
+ if blk_item is None:
+ self.hide()
+ return
+ blk_item.under_ctrl = True
+ blk_item.update()
+ self.updateBoundingRect()
+ self.show()
+
+ def updateBoundingRect(self):
+ if self.blk_item is None:
+ return
+ abr = self.blk_item.absBoundingRect(qrect=True)
+ br = QRectF(0, 0, abr.width(), abr.height())
+ self.setRect(br)
+ self.blk_item.setCenterTransform()
+ self.setTransformOriginPoint(self.blk_item.transformOriginPoint())
+ self.setPos(abr.x(), abr.y())
+ self.setAngle(self.blk_item.angle)
+
+ def setRect(self, *args):
+ super().setRect(*args)
+ self.updateControlBlocks()
+
+ def updateControlBlocks(self):
+ b_rect = self.rect()
+ b_rect = [b_rect.x(), b_rect.y(), b_rect.width(), b_rect.height()]
+ corner_pnts = xywh2xyxypoly(np.array([b_rect])).reshape(-1, 2)
+ edge_pnts = (corner_pnts[[1, 2, 3, 0]] + corner_pnts) / 2
+ pnts = [edge_pnts, corner_pnts]
+ for ii, ctrlblock in enumerate(self.ctrlblock_group):
+ is_corner = not ii % 2
+ idx = ii // 2
+ hitbox_xy = ctrlidx_to_hitbox[ii][:2]
+ pos = pnts[is_corner][idx] + hitbox_xy * ctrlblock.edge_width
+ ctrlblock.setPos(pos[0], pos[1])
+
+ def setAngle(self, angle: int) -> None:
+ center = self.boundingRect().center()
+ self.setTransformOriginPoint(center)
+ self.setRotation(angle)
+
+ def ctrlblockPressed(self):
+ self.scene().clearSelection()
+ if self.blk_item is not None:
+ self.blk_item.endEdit()
+
+ def paint(self, painter: QPainter, option: 'QStyleOptionGraphicsItem', widget = ...) -> None:
+ painter.setCompositionMode(QPainter.CompositionMode.RasterOp_NotDestination)
+ super().paint(painter, option, widget)
+
+ def hideControls(self):
+ for ctrl in self.ctrlblock_group:
+ ctrl.hide()
+
+ def showControls(self):
+ for ctrl in self.ctrlblock_group:
+ ctrl.show()
+
+ def updateScale(self, scale: float):
+ if not self.isVisible():
+ if scale != self.current_scale:
+ self.need_rescale = True
+ self.current_scale = scale
+ return
+
+ self.current_scale = scale
+ scale = 1 / scale
+ pen = self.pen()
+ pen.setWidthF(2 * scale)
+ self.setPen(pen)
+ for ctrl in self.ctrlblock_group:
+ ctrl.updateEdgeWidth(CBEDGE_WIDTH * scale)
+
+ def show(self) -> None:
+ super().show()
+ if self.need_rescale:
+ self.updateScale(self.current_scale)
+ self.need_rescale = False
+ self.setZValue(1)
+
+ def startEditing(self):
+ self.setCursor(Qt.CursorShape.IBeamCursor)
+ for ctrlb in self.ctrlblock_group:
+ ctrlb.hide()
+
+ def endEditing(self):
+ self.setCursor(Qt.CursorShape.SizeAllCursor)
+ if self.isVisible():
+ for ctrlb in self.ctrlblock_group:
+ ctrlb.show()
\ No newline at end of file
diff --git a/ui/textitem.py b/ui/textitem.py
new file mode 100644
index 0000000000000000000000000000000000000000..d26c46a7452b097bd73d7e2be6b959e50b46729e
--- /dev/null
+++ b/ui/textitem.py
@@ -0,0 +1,1122 @@
+import math, re
+import numpy as np
+from typing import List, Union, Tuple
+
+from qtpy.QtWidgets import QGraphicsItem, QWidget, QGraphicsSceneHoverEvent, QGraphicsTextItem, QStyleOptionGraphicsItem, QStyle, QGraphicsSceneMouseEvent
+from qtpy.QtCore import Qt, QRect, QRectF, QPointF, Signal, QSizeF
+from qtpy.QtGui import (QGradient, QKeyEvent, QFont, QTextCursor, QPixmap, QPainterPath, QTextDocument,
+ QInputMethodEvent, QPainter, QPen, QColor, QTextCharFormat, QTextDocument, QLinearGradient,
+ QBrush, QPalette, QAbstractTextDocumentLayout)
+
+from utils.textblock import TextBlock, FontFormat, TextAlignment, LineSpacingType
+from utils.imgproc_utils import xywh2xyxypoly, rotate_polygons
+from utils.fontformat import FontFormat, px2pt, pt2px
+from .misc import td_pattern, table_pattern
+from .scene_textlayout import VerticalTextDocumentLayout, HorizontalTextDocumentLayout, SceneTextLayout
+from .text_graphical_effect import apply_shadow_effect
+
+TEXTRECT_SHOW_COLOR = QColor(30, 147, 229, 170)
+TEXTRECT_SELECTED_COLOR = QColor(248, 64, 147, 170)
+
+
+class TextBlkItem(QGraphicsTextItem):
+
+ begin_edit = Signal(int)
+ end_edit = Signal(int)
+ hover_enter = Signal(int)
+ hover_move = Signal(int)
+ moved = Signal()
+ moving = Signal(QGraphicsTextItem)
+ rotated = Signal(float)
+ reshaped = Signal(QGraphicsTextItem)
+ leftbutton_pressed = Signal(int)
+ doc_size_changed = Signal(int)
+ pasted = Signal(int)
+ redo_signal = Signal()
+ undo_signal = Signal()
+ push_undo_stack = Signal(int, bool)
+ propagate_user_edited = Signal(int, str, bool)
+
+ def __init__(self, blk: TextBlock = None, idx: int = 0, set_format=True, show_rect=False, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.pre_editing = False
+ self.blk: TextBlock = None
+ self.fontformat: FontFormat = None
+ self.repainting = False
+ self.reshaping = False
+ self.under_ctrl = False
+ self.draw_rect = show_rect
+ self._display_rect: QRectF = QRectF(0, 0, 1, 1)
+ self.old_ffmt_values = None
+
+ self.idx = idx
+
+ self.background_pixmap: QPixmap = None
+ self.stroke_qcolor = QColor(0, 0, 0)
+ self.oldPos = QPointF()
+ self.oldRect = QRectF()
+ self.repaint_on_changed = True
+
+ self.is_formatting = False
+ self.old_undo_steps = 0
+ self.in_redo_undo = False
+ self.change_from: int = 0
+ self.change_added: int = 0
+ self.input_method_from = -1
+ self.input_method_text = ''
+ self.block_all_input = False
+ self.block_change_signal = False
+
+ self.layout: Union[VerticalTextDocumentLayout, HorizontalTextDocumentLayout] = None
+ self.document().setDocumentMargin(0)
+ self.initTextBlock(blk, set_format=set_format)
+ self.setBoundingRegionGranularity(0)
+ self.setFlags(QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemIsSelectable)
+ self.setCacheMode(QGraphicsItem.CacheMode.DeviceCoordinateCache)
+
+ def inputMethodEvent(self, e: QInputMethodEvent):
+ if self.pre_editing == False:
+ cursor = self.textCursor()
+ self.input_method_from = cursor.selectionStart()
+ if e.preeditString() == '':
+ self.pre_editing = False
+ self.input_method_text = e.commitString()
+ else:
+ self.pre_editing = True
+ super().inputMethodEvent(e)
+
+ def is_editting(self):
+ return self.textInteractionFlags() == Qt.TextInteractionFlag.TextEditorInteraction
+
+ def on_content_changed(self):
+ if (self.hasFocus() or self.is_formatting) and not self.pre_editing and not self.block_change_signal:
+ # self.content_changed.emit(self)
+ if not self.in_redo_undo:
+ undo_steps = self.document().availableUndoSteps()
+ new_steps = undo_steps - self.old_undo_steps
+ joint_previous = new_steps == 0
+
+ if not self.is_formatting:
+ change_from = self.change_from
+ added_text = ''
+ if self.input_method_from != -1:
+ added_text = self.input_method_text
+ change_from = self.input_method_from
+ self.input_method_from = -1
+
+ elif self.change_added > 0:
+ cursor = self.textCursor()
+ cursor.setPosition(change_from)
+ cursor.setPosition(change_from + self.change_added, QTextCursor.MoveMode.KeepAnchor)
+ added_text = cursor.selectedText()
+
+ self.propagate_user_edited.emit(change_from, added_text, joint_previous)
+ self.change_added = 0
+
+ if new_steps > 0:
+ self.old_undo_steps = undo_steps
+ self.push_undo_stack.emit(new_steps, self.is_formatting)
+
+ if not (self.hasFocus() and self.pre_editing):
+ if self.repaint_on_changed:
+ if not self.repainting:
+ self.repaint_background()
+ self.update()
+
+ def paint_stroke(self, painter: QPainter):
+ doc = QTextDocument()
+ doc.setUndoRedoEnabled(False)
+ doc.setDocumentMargin(self.document().documentMargin())
+ doc.setDefaultFont(self.document().defaultFont())
+ doc.setHtml(self.document().toHtml())
+ doc.setDefaultTextOption(self.document().defaultTextOption())
+ cursor = QTextCursor(doc)
+ block = doc.firstBlock()
+ stroke_pen = QPen(self.stroke_qcolor, 0, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap, Qt.PenJoinStyle.RoundJoin)
+ letter_spacing = self.fontformat.letter_spacing * 100
+ while block.isValid():
+ it = block.begin()
+ while not it.atEnd():
+ fragment = it.fragment()
+ cfmt = fragment.charFormat()
+ sw = pt2px(cfmt.fontPointSize()) * self.fontformat.stroke_width
+ stroke_pen.setWidthF(sw)
+ pos1 = fragment.position()
+ pos2 = pos1 + fragment.length()
+ cursor.setPosition(pos1)
+ cursor.setPosition(pos2, QTextCursor.MoveMode.KeepAnchor)
+ cfmt.setTextOutline(stroke_pen)
+ if letter_spacing != 100 and not self.fontformat.vertical:
+ cfmt.setFontLetterSpacingType(QFont.SpacingType.PercentageSpacing)
+ cfmt.setFontLetterSpacing(letter_spacing)
+ cursor.mergeCharFormat(cfmt)
+ it += 1
+ block = block.next()
+
+ layout = VerticalTextDocumentLayout(doc, self.fontformat) if self.fontformat.vertical \
+ else HorizontalTextDocumentLayout(doc, self.fontformat)
+ layout._draw_offset = self.layout._draw_offset
+ layout._is_painting_stroke = True
+ layout.setMaxSize(self.layout.max_width, self.layout.max_height, False)
+ doc.setDocumentLayout(layout)
+
+ layout.relayout_on_changed = False
+ doc.drawContents(painter)
+
+ def repaint_background(self):
+ empty = self.document().isEmpty()
+ if self.repainting:
+ return
+
+ paint_stroke = self.fontformat.stroke_width > 0
+ paint_shadow = self.fontformat.shadow_radius > 0 and self.fontformat.shadow_strength > 0
+ if not paint_shadow and not paint_stroke or empty:
+ self.background_pixmap = None
+ return
+
+ self.repainting = True
+ font_size = self.layout.max_font_size(to_px=True)
+ target_map = QPixmap(self.boundingRect().size().toSize())
+ target_map.fill(Qt.GlobalColor.transparent)
+ painter = QPainter(target_map)
+ painter.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform)
+
+ if paint_stroke:
+ self.paint_stroke(painter)
+ else:
+ self.document().drawContents(painter)
+
+ # shadow
+ if paint_shadow:
+ r = int(round(self.fontformat.shadow_radius * font_size))
+ xoffset, yoffset = int(self.fontformat.shadow_offset[0] * font_size), int(self.fontformat.shadow_offset[1] * font_size)
+ shadow_map, img_array = apply_shadow_effect(target_map, self.fontformat.shadow_color, self.fontformat.shadow_strength, r)
+ cm = painter.compositionMode()
+ painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_DestinationOver)
+ painter.drawPixmap(xoffset, yoffset, shadow_map)
+ painter.setCompositionMode(cm)
+
+ painter.end()
+ self.background_pixmap = target_map
+ self.repainting = False
+
+ def docSizeChanged(self):
+ self.setCenterTransform()
+ self.doc_size_changed.emit(self.idx)
+
+ def initTextBlock(self, blk: TextBlock = None, set_format=True):
+ self.blk = blk
+ self.fontformat = blk.fontformat
+ if blk is None:
+ xyxy = [0, 0, 0, 0]
+ blk = TextBlock(xyxy)
+ blk.lines = [xyxy]
+ bx1, by1, bx2, by2 = xyxy
+ xywh = np.array([[bx1, by1, bx2-bx1, by2-by1]])
+ blk.lines = xywh2xyxypoly(xywh).reshape(-1, 4, 2).tolist()
+ self.setVertical(blk.vertical)
+ self.setRect(blk.bounding_rect())
+
+ if blk.angle != 0:
+ self.setRotation(blk.angle)
+
+ set_char_fmt = False
+ if blk.translation:
+ set_char_fmt = True
+
+ font_fmt = blk.fontformat
+ if set_format:
+ self.set_fontformat(font_fmt, set_char_format=set_char_fmt, set_stroke_width=False, set_effect=False)
+
+ if not blk.rich_text:
+ if blk.translation:
+ self.setPlainText(blk.translation)
+ else:
+ self.setHtml(blk.rich_text)
+ self.setLetterSpacing(font_fmt.letter_spacing, repaint_background=False)
+ cursor = self.textCursor()
+ cursor.clearSelection()
+ cursor.movePosition(QTextCursor.MoveOperation.Start)
+ cfmt = cursor.charFormat()
+ cursor.setCharFormat(cfmt)
+ cursor.setBlockCharFormat(cfmt)
+ self.setTextCursor(cursor)
+ if self.fontformat.gradient_enabled:
+ self.setGradientEnabled(True)
+ self.setShadow(font_fmt, repaint=False)
+ self.setStrokeWidth(font_fmt.stroke_width, repaint_background=False)
+ self.repaint_background()
+
+ def setCenterTransform(self):
+ center = self.boundingRect().center()
+ self.setTransformOriginPoint(center)
+
+ def rect(self) -> QRectF:
+ return QRectF(self.pos(), self.boundingRect().size())
+
+ def startReshape(self):
+ self.oldRect = self.absBoundingRect(qrect=True)
+ self.reshaping = True
+
+ def endReshape(self):
+ self.reshaped.emit(self)
+ self.reshaping = False
+
+ def padRect(self, rect: QRectF) -> QRectF:
+ p = self.padding()
+ P = p * 2
+ return QRectF(rect.x() - p, rect.y() - p, rect.width() + P, rect.height() + P)
+
+ def unpadRect(self, rect: QRectF) -> QRectF:
+ p = -self.padding()
+ P = p * 2
+ return QRectF(rect.x() - p, rect.y() - p, rect.width() + P, rect.height() + P)
+
+ def setRect(self, rect: Union[List, QRectF], padding=True, repaint=True) -> None:
+
+ if isinstance(rect, List):
+ rect = QRectF(*rect)
+ if padding:
+ rect = self.padRect(rect)
+ self.setPos(rect.topLeft())
+ self.prepareGeometryChange()
+ self._display_rect = rect
+ self.layout.setMaxSize(rect.width(), rect.height())
+ self.setCenterTransform()
+ if repaint:
+ self.repaint_background()
+
+ def documentSize(self):
+ return self.layout.documentSize()
+
+ def boundingRect(self) -> QRectF:
+ br = super().boundingRect()
+ if self._display_rect is not None:
+ br.setHeight(self._display_rect.height())
+ br.setWidth(self._display_rect.width())
+ return br
+
+ def padding(self) -> float:
+ return self.document().documentMargin()
+
+ def setPadding(self, p: float):
+ _p = self.padding()
+ if _p >= p:
+ return
+ abr = self.absBoundingRect(qrect=True)
+ self.layout.relayout_on_changed = False
+ self.layout.updateDocumentMargin(p)
+ self.layout.relayout_on_changed = True
+ self.setRect(abr, repaint=False)
+
+ def absBoundingRect(self, max_h=None, max_w=None, qrect=False) -> Union[List, QRectF]:
+ br = self.boundingRect()
+ P = 2 * self.padding()
+ w, h = br.width() - P, br.height() - P
+ pos = self.pos()
+ x = pos.x() + self.padding()
+ y = pos.y() + self.padding()
+ if max_h is not None:
+ y = min(max(0, y), max_h)
+ y1 = y + h
+ h = min(max_h, y1) - y
+ if max_w is not None:
+ x = min(max(0, x), max_w)
+ x1 = x + w
+ w = min(max_w, x1) - x
+ if qrect:
+ return QRectF(x, y, w, h)
+ return [int(round(x)), int(round(y)), math.ceil(w), math.ceil(h)]
+
+ def shape(self) -> QPainterPath:
+ path = QPainterPath()
+ br = self.boundingRect()
+ path.addRect(br)
+ return path
+
+ def setScale(self, scale: float) -> None:
+ self.setTransformOriginPoint(0, 0)
+ super().setScale(scale)
+ self.setCenterTransform()
+
+ @property
+ def angle(self) -> int:
+ return self.blk.angle
+
+ def toTextBlock(self) -> TextBlock:
+ raise NotImplementedError
+
+ def setAngle(self, angle: int):
+ self.setCenterTransform()
+ if self.blk.angle != angle:
+ self.setRotation(angle)
+ self.blk.angle = angle
+
+ def setVertical(self, vertical: bool):
+ if self.fontformat is not None:
+ self.fontformat.vertical = vertical
+
+ valid_layout = True
+ doc = self.document()
+ if self.layout is not None:
+ if isinstance(self.layout, VerticalTextDocumentLayout) == vertical:
+ return
+ self.layout.size_enlarged.disconnect(self.on_document_enlarged)
+ self.layout.documentSizeChanged.disconnect(self.docSizeChanged)
+ else:
+ valid_layout = False
+ doc.contentsChanged.connect(self.on_content_changed)
+ doc.contentsChange.connect(self.on_content_changing)
+
+ if valid_layout:
+ rect = self.rect() if self.layout is not None else None
+
+ self.setTextInteractionFlags(Qt.TextInteractionFlag.NoTextInteraction)
+ doc.documentLayout().blockSignals(True)
+ if vertical:
+ layout = VerticalTextDocumentLayout(doc, self.fontformat)
+ else:
+ layout = HorizontalTextDocumentLayout(doc, self.fontformat)
+
+ self.layout = layout
+ doc.setDocumentLayout(layout)
+ layout.size_enlarged.connect(self.on_document_enlarged)
+ layout.documentSizeChanged.connect(self.docSizeChanged)
+
+ if valid_layout:
+ layout.setMaxSize(rect.width(), rect.height())
+ self.setCenterTransform()
+ self.repaint_background()
+ self.doc_size_changed.emit(self.idx)
+
+ def updateUndoSteps(self):
+ self.old_undo_steps = self.document().availableUndoSteps()
+
+ def on_content_changing(self, from_: int, removed: int, added: int):
+ if not self.pre_editing:
+ if self.hasFocus():
+ self.change_from = from_
+ self.change_added = added
+
+ def keyPressEvent(self, e: QKeyEvent) -> None:
+
+ if self.block_all_input:
+ e.setAccepted(True)
+ return
+
+ if e.modifiers() == Qt.KeyboardModifier.ControlModifier:
+ if e.key() == Qt.Key.Key_Z:
+ e.accept()
+ self.undo_signal.emit()
+ return
+ elif e.key() == Qt.Key.Key_Y:
+ e.accept()
+ self.redo_signal.emit()
+ return
+ elif e.key() == Qt.Key.Key_V:
+ if self.isEditing():
+ e.accept()
+ self.pasted.emit(self.idx)
+ return
+ elif e.modifiers() == Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.ShiftModifier:
+ if e.key() == Qt.Key.Key_Z:
+ e.accept()
+ self.redo_signal.emit()
+ return
+ elif e.key() == Qt.Key.Key_Return:
+ e.accept()
+ self.textCursor().insertText('\n')
+ return
+ return super().keyPressEvent(e)
+
+ def undo(self) -> None:
+ self.in_redo_undo = True
+ self.document().undo()
+ self.in_redo_undo = False
+ self.old_undo_steps = self.document().availableUndoSteps()
+
+ def redo(self) -> None:
+ self.in_redo_undo = True
+ self.document().redo()
+ self.in_redo_undo = False
+ self.old_undo_steps = self.document().availableUndoSteps()
+
+ def on_document_enlarged(self):
+ size = self.documentSize()
+ self.set_size(size.width(), size.height())
+
+ def get_scale(self) -> float:
+ tl = self.topLevelItem()
+ if tl is not None:
+ return tl.scale()
+ else:
+ return self.scale()
+
+ def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, widget: QWidget) -> None:
+ # subpixel antialiasing is enabled for super().paint upon drawing on some non-transparent background https://github.com/dmMaze/BallonsTranslator/issues/919
+ # which can be avoided by calling super().paint first, but it results in disappeared background in editting mode
+ # so the checking logic lies here
+
+ if self.is_editting():
+ self._draw_accessories(painter)
+
+ option.state = QStyle.State_None
+ super().paint(painter, option, widget)
+
+ if not self.is_editting():
+ painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_DestinationOver)
+ self._draw_accessories(painter)
+ painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_SourceOver)
+
+
+ def _draw_accessories(self, painter: QPainter):
+ br = self.boundingRect()
+ painter.save()
+
+ if self.background_pixmap is not None:
+ painter.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform)
+ painter.drawPixmap(br.toRect(), self.background_pixmap)
+
+ draw_rect = self.draw_rect and not self.under_ctrl
+ if self.isSelected() and not self.is_editting():
+ pen = QPen(TEXTRECT_SELECTED_COLOR, 3.5 / self.get_scale(), Qt.PenStyle.DashLine)
+ painter.setPen(pen)
+ painter.drawRect(self.unpadRect(br))
+ elif draw_rect:
+ pen = QPen(TEXTRECT_SHOW_COLOR, 3 / self.get_scale(), Qt.PenStyle.SolidLine)
+ painter.setPen(pen)
+ painter.drawRect(self.unpadRect(br))
+ painter.restore()
+
+
+ def startEdit(self, pos: QPointF = None) -> None:
+ self.pre_editing = False
+ self.setCacheMode(QGraphicsItem.CacheMode.NoCache)
+ self.setTextInteractionFlags(Qt.TextInteractionFlag.TextEditorInteraction)
+ self.setFocus()
+ self.begin_edit.emit(self.idx)
+ if pos is not None:
+ hit = self.layout.hitTest(pos, None)
+ cursor = self.textCursor()
+ cursor.setPosition(hit)
+ self.setTextCursor(cursor)
+
+ def endEdit(self, keep_focus=True) -> None:
+ self.end_edit.emit(self.idx)
+ cursor = self.textCursor()
+ cursor.clearSelection()
+ self.setTextCursor(cursor)
+ self.setTextInteractionFlags(Qt.TextInteractionFlag.NoTextInteraction)
+ self.setCacheMode(QGraphicsItem.CacheMode.DeviceCoordinateCache)
+ if keep_focus:
+ self.setFocus()
+
+ def isEditing(self) -> bool:
+ return self.textInteractionFlags() == Qt.TextInteractionFlag.TextEditorInteraction
+
+ def isMultiFontSize(self) -> bool:
+ doc = self.document()
+ block = doc.firstBlock()
+ if block.isValid():
+ it = block.begin()
+ if it.atEnd():
+ firstFontSize = block.charFormat().fontPointSize()
+ else:
+ # empty blocks causes frozen for pyside==6.8.1
+ # also randomly freezes pyqt==6.6.1 https://github.com/dmMaze/BallonsTranslator/issues/736
+ firstFontSize = it.fragment().charFormat().fontPointSize()
+ else:
+ return False
+ while block.isValid():
+ it = block.begin()
+ while not it.atEnd():
+ fragment = it.fragment()
+ font_size = fragment.charFormat().fontPointSize()
+ if not firstFontSize == font_size:
+ return True
+ it += 1
+ block = block.next()
+ return False
+
+ def minFontSize(self, to_px=True):
+ doc = self.document()
+ block = doc.firstBlock()
+ min_font_size = self.textCursor().charFormat().fontPointSize()
+ while block.isValid():
+ it = block.begin()
+ while not it.atEnd():
+ fragment = it.fragment()
+ font_size = fragment.charFormat().fontPointSize()
+ min_font_size = min(min_font_size, font_size)
+ it += 1
+ block = block.next()
+ if to_px:
+ min_font_size = pt2px(min_font_size)
+ return min_font_size
+
+ def mouseDoubleClickEvent(self, event: QGraphicsSceneMouseEvent) -> None:
+ if not self.isEditing():
+ self.startEdit(pos=event.pos())
+ else:
+ super().mouseDoubleClickEvent(event)
+
+ def mouseMoveEvent(self, event: QGraphicsSceneMouseEvent) -> None:
+ super().mouseMoveEvent(event)
+ if self.textInteractionFlags() != Qt.TextInteractionFlag.TextEditorInteraction:
+ self.moving.emit(self)
+
+ # QT 5.15.x causing segmentation fault
+ def contextMenuEvent(self, event):
+ return super().contextMenuEvent(event)
+
+ def mousePressEvent(self, event: QGraphicsSceneMouseEvent) -> None:
+ if event.button() == Qt.MouseButton.LeftButton:
+ self.oldPos = self.pos()
+ self.leftbutton_pressed.emit(self.idx)
+ return super().mousePressEvent(event)
+
+ def mouseReleaseEvent(self, event: QGraphicsSceneMouseEvent) -> None:
+ if event.button() == Qt.MouseButton.LeftButton:
+ if self.oldPos != self.pos():
+ self.moved.emit()
+ super().mouseReleaseEvent(event)
+
+ def hoverMoveEvent(self, event: QGraphicsSceneHoverEvent) -> None:
+ self.hover_move.emit(self.idx)
+ return super().hoverMoveEvent(event)
+
+ def hoverEnterEvent(self, event: QGraphicsSceneHoverEvent) -> None:
+ self.hover_enter.emit(self.idx)
+ return super().hoverEnterEvent(event)
+
+ def toPixmap(self) -> QPixmap:
+ pixmap = QPixmap(self.boundingRect().size().toSize())
+ pixmap.fill(Qt.GlobalColor.transparent)
+ painter = QPainter(pixmap)
+ doc = self.document()
+ doc.drawContents(painter)
+ painter.end()
+ return pixmap
+
+ def toHtml(self) -> str:
+ html = super().toHtml()
+ tables = table_pattern.findall(html)
+ if tables:
+ _, td = td_pattern.findall(html)[0]
+ html = tables[0] + td + '