GameSentenceMiner 2.19.5__py3-none-any.whl → 2.19.7__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -28,7 +28,7 @@ import re
 import platform
 import sys
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Dict, Any, List
 
 # Global variables to track state
@@ -58,6 +58,8 @@ class MediaAssets:
     final_prev_screenshot_path: str = ''
     final_video_path: str = ''
 
+    extra_tags: List[str] = field(default_factory=list)
+
 
 def _determine_update_conditions(last_note: 'AnkiCard') -> (bool, bool):
     """Determine if audio and picture fields should be updated."""
@@ -83,7 +85,10 @@ def _generate_media_files(reuse_audio: bool, game_line: 'GameLine', video_path:
         assets.screenshot_in_anki = anki_result.screenshot_in_anki
         assets.prev_screenshot_in_anki = anki_result.prev_screenshot_in_anki
         assets.video_in_anki = anki_result.video_in_anki
+        assets.extra_tags = anki_result.extra_tags
         return assets
+    
+    assets.extra_tags = []
 
     # --- Generate new media files ---
     if config.anki.picture_field and config.screenshot.enabled:
@@ -242,7 +247,7 @@ def update_anki_card(last_note: 'AnkiCard', note=None, audio_path='', video_path
         
         # Add NSFW tag if checkbox was selected
         if add_nsfw_tag:
-            tags.append("NSFW")
+            assets.extra_tags.append("NSFW")
 
     # 5. If creating new media, store files in Anki's collection. Then update note fields.
     if not use_existing_files:
@@ -266,6 +271,9 @@ def update_anki_card(last_note: 'AnkiCard', note=None, audio_path='', video_path
         if config.audio.external_tool and config.audio.external_tool_enabled:
             anki_media_audio_path = os.path.join(config.audio.anki_media_collection, assets.audio_in_anki)
             open_audio_in_external(anki_media_audio_path)
+            
+    for extra_tag in assets.extra_tags:
+        tags.append(extra_tag)
 
     # 6. Asynchronously update the note in Anki
     run_new_thread(lambda: check_and_update_note(last_note, note, tags))
@@ -284,7 +292,8 @@ def update_anki_card(last_note: 'AnkiCard', note=None, audio_path='', video_path
             multi_line=bool(selected_lines and len(selected_lines) > 1),
             video_in_anki=assets.video_in_anki or '',
             word_path=word_path,
-            word=tango
+            word=tango,
+            extra_tags=assets.extra_tags
         )
     
     # 9. Update the local application database with final paths

GameSentenceMiner/gsm.py

@@ -144,6 +144,8 @@ procs_to_close = []
 settings_window: config_gui.ConfigApp = None
 obs_paused = False
 root = None
+file_watcher_observer = None  # Global observer for file watching
+file_watcher_path = None  # Track the currently watched path
 warnings.simplefilter("ignore", DeprecationWarning)
 
 
@@ -595,6 +597,14 @@ def cleanup():
         if gsm_tray:
             gsm_tray.stop()
 
+        # Stop file watcher observer
+        if file_watcher_observer:
+            try:
+                file_watcher_observer.stop()
+                file_watcher_observer.join()
+            except Exception as e:
+                logger.error(f"Error stopping file watcher observer: {e}")
+
         for video in gsm_state.videos_to_remove:
             try:
                 if os.path.exists(video):
@@ -622,6 +632,43 @@ def handle_exit():
     return _handle_exit
 
 
+def start_file_watcher():
+    """Start or restart the file watcher with current config."""
+    global file_watcher_observer, file_watcher_path
+    
+    # Stop existing observer if running
+    if file_watcher_observer:
+        try:
+            file_watcher_observer.stop()
+            file_watcher_observer.join(timeout=2)
+            logger.info("Stopped existing file watcher")
+        except Exception as e:
+            logger.error(f"Error stopping file watcher: {e}")
+    
+    # Create and start new observer
+    watch_path = get_config().paths.folder_to_watch
+    os.makedirs(watch_path, exist_ok=True)
+    
+    file_watcher_observer = Observer()
+    file_watcher_observer.schedule(VideoToAudioHandler(), watch_path, recursive=False)
+    file_watcher_observer.start()
+    file_watcher_path = watch_path
+    logger.info(f"File watcher started for: {watch_path}")
+
+
+def on_config_changed():
+    """Called when config is saved/changed. Restarts file watcher if path changed."""
+    global file_watcher_path
+    
+    new_path = get_config().paths.folder_to_watch
+    
+    if file_watcher_path != new_path:
+        logger.info(f"Watch path changed from '{file_watcher_path}' to '{new_path}', restarting file watcher...")
+        start_file_watcher()
+    else:
+        logger.debug("Config changed, but watch path unchanged - no restart needed")
+
+
 def initialize(reloading=False):
     global obs_process
     if not reloading:
@@ -703,6 +750,10 @@ def async_loop():
         await obs.connect_to_obs(connections=3, check_output=True)
         await register_scene_switcher_callback()
         await check_obs_folder_is_correct()
+        
+        # Start file watcher after OBS path is verified/corrected
+        start_file_watcher()
+        
         vad_processor.init()
         await init_overlay_processor()
 
@@ -787,10 +838,6 @@ async def async_main(reloading=False):
         settings_window = config_gui.ConfigApp(root)
         gsm_state.config_app = settings_window
         initialize_async()
-        observer = Observer()
-        observer.schedule(VideoToAudioHandler(),
-                          get_config().paths.folder_to_watch, recursive=False)
-        observer.start()
         if is_windows():
             register_hotkeys()
 
@@ -821,16 +868,11 @@ async def async_main(reloading=False):
             #     audio_path="C:/path/to/my/audio.mp3",
             #     translation="Hello world! How are you?"))
             settings_window.add_save_hook(gsm_tray.update_icon)
+            settings_window.add_save_hook(on_config_changed)
             settings_window.on_exit = exit_program
             root.mainloop()
         except KeyboardInterrupt:
             cleanup()
-
-        try:
-            observer.stop()
-            observer.join()
-        except Exception as e:
-            logger.error(f"Error stopping observer: {e}")
     except Exception as e:
         handle_error_in_initialization(e)
 

GameSentenceMiner/locales/en_us.json

@@ -358,6 +358,10 @@
           "hotkey_updates_anki": {
             "label": "Screenshot Hotkey Updates Anki:",
             "tooltip": "Enable to allow Screenshot hotkey/button to update the latest anki card."
+          },
+          "trim_black_bars": {
+            "label": "Trim Black Bars:",
+            "tooltip": "Automatically trim black bars from screenshots. Useful for games with letterboxing/pillarboxing (e.g., 4:3 games on 16:9 displays)."
           }
         },
         "audio": {

GameSentenceMiner/locales/ja_jp.json

@@ -357,6 +357,10 @@
           "hotkey_updates_anki": {
             "label": "ホットキーでAnkiを更新:",
             "tooltip": "撮影ホットキーで最新のAnkiカードを更新できるようにします。"
+          },
+          "trim_black_bars": {
+            "label": "黒帯をトリミング:",
+            "tooltip": "スクリーンショットから黒帯を自動的にトリミングします。レターボックス/ピラーボックスのあるゲーム（16:9ディスプレイ上の4:3ゲームなど）に便利です。"
           }
         },
         "audio": {

GameSentenceMiner/locales/zh_cn.json

@@ -358,6 +358,10 @@
           "hotkey_updates_anki": {
             "label": "截图热键更新 Anki:",
             "tooltip": "允许截图热键/按钮更新最新的 Anki 卡片。"
+          },
+          "trim_black_bars": {
+            "label": "裁剪黑边:",
+            "tooltip": "自动裁剪截图中的黑边。适用于有信箱/柱状框的游戏（例如在 16:9 显示器上的 4:3 游戏）。"
           }
         },
         "audio": {

GameSentenceMiner/obs.py

@@ -565,6 +565,24 @@ def get_active_source():
         return None
     return get_source_from_scene(current_game)
 
+def get_active_video_sources():
+    current_game = get_current_game()
+    if not current_game:
+        return None
+    scene_items_response = []
+    try:
+        with connection_pool.get_client() as client:
+            client: obs.ReqClient
+            response = client.get_scene_item_list(name=current_game)
+            scene_items_response = response.scene_items if response else []
+    except Exception as e:
+        logger.error(f"Error getting scene items for active video source: {e}")
+        return None
+    if not scene_items_response:
+        return None
+    video_sources = ['window_capture', 'game_capture', 'monitor_capture']
+    return [item for item in scene_items_response if item.get('inputKind') in video_sources]
+
 def get_record_directory():
     try:
         with connection_pool.get_client() as client:
@@ -709,32 +727,143 @@ def get_screenshot_base64(compression=75, width=None, height=None):
         return None
     
 
-def get_screenshot_PIL(source_name=None, compression=75, img_format='png', width=None, height=None, retry=3):
+def get_screenshot_PIL_from_source(source_name, compression=75, img_format='png', width=None, height=None, retry=3):
+    """
+    Get a PIL Image screenshot from a specific OBS source.
+    
+    Args:
+        source_name: The name of the OBS source to capture
+        compression: Image quality (0-100)
+        img_format: Image format ('png' or 'jpg')
+        width: Optional width to resize
+        height: Optional height to resize
+        retry: Number of retry attempts
+        
+    Returns:
+        PIL.Image or None if failed
+    """
     import io
     import base64
     from PIL import Image
+    
     if not source_name:
-        source_name = get_active_source().get('sourceName', None)
-    if not source_name:
-        logger.error("No active source found in the current scene.")
+        logger.error("No source name provided.")
         return None
-    while True:
-        with connection_pool.get_client() as client:
-            client: obs.ReqClient
-            response = client.get_source_screenshot(name=source_name, img_format=img_format, quality=compression, width=width, height=height)
+        
+    for attempt in range(retry):
         try:
-            response.image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
+            with connection_pool.get_client() as client:
+                client: obs.ReqClient
+                response = client.get_source_screenshot(name=source_name, img_format=img_format, quality=compression, width=width, height=height)
+            
+            if response and hasattr(response, 'image_data') and response.image_data:
+                image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
+                image_data = base64.b64decode(image_data)
+                img = Image.open(io.BytesIO(image_data)).convert("RGBA")
+                return img
         except AttributeError:
-            retry -= 1
-            if retry <= 0:
-                logger.error(f"Error getting screenshot: {response}")
+            if attempt >= retry - 1:
+                logger.error(f"Error getting screenshot from source '{source_name}': Invalid response")
                 return None
+            time.sleep(0.1)
+        except Exception as e:
+            logger.error(f"Error getting screenshot from source '{source_name}': {e}")
+            return None
+    
+    return None
+
+
+def get_best_source_for_screenshot():
+    """
+    Get the best available video source dict based on priority and image validation.
+    
+    Priority order: window_capture > game_capture > monitor_capture
+    
+    Returns:
+        The source dict of the best available source, or None if no valid source found.
+    """
+    return get_screenshot_PIL(return_source_dict=True)
+
+
+def get_screenshot_PIL(source_name=None, compression=75, img_format='png', width=None, height=None, retry=3, return_source_dict=False):
+    """
+    Get a PIL Image screenshot. If no source_name is provided, automatically selects
+    the best available source based on priority and validates it has actual image data.
+    
+    Priority order: window_capture > game_capture > monitor_capture
+    
+    Args:
+        source_name: Optional specific OBS source name. If None, auto-selects best source.
+        compression: Image quality (0-100)
+        img_format: Image format ('png' or 'jpg')
+        width: Optional width to resize
+        height: Optional height to resize
+        retry: Number of retry attempts
+        return_source_dict: If True, returns only the source dict. If False, returns only the PIL.Image.
+        
+    Returns:
+        PIL.Image if return_source_dict=False, or source dict if return_source_dict=True.
+        Returns None if failed.
+    """
+    import io
+    import base64
+    from PIL import Image
+    
+    # If source_name is provided, use it directly
+    if source_name:
+        if return_source_dict:
+            # Need to find the source dict for this source_name
+            current_sources = get_active_video_sources()
+            if current_sources:
+                for src in current_sources:
+                    if src.get('sourceName') == source_name:
+                        return src
+            return None
+        img = get_screenshot_PIL_from_source(source_name, compression, img_format, width, height, retry)
+        return img
+    
+    # Get all available video sources
+    current_sources = get_active_video_sources()
+    if not current_sources:
+        logger.error("No active video sources found in the current scene.")
+        return None
+    
+    # Priority: window_capture (0) > game_capture (1) > monitor_capture (2)
+    priority_map = {'window_capture': 0, 'game_capture': 1, 'monitor_capture': 2}
+    
+    # Sort sources by priority
+    sorted_sources = sorted(
+        current_sources,
+        key=lambda x: priority_map.get(x.get('inputKind'), 999)
+    )
+    
+    # Try each source in priority order
+    for source in sorted_sources:
+        found_source_name = source.get('sourceName')
+        if not found_source_name:
             continue
-        if response and response.image_data:
-            image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
-            image_data = base64.b64decode(image_data)
-            img = Image.open(io.BytesIO(image_data)).convert("RGBA")
-            return img
+            
+        img = get_screenshot_PIL_from_source(found_source_name, compression, img_format, width, height, retry)
+        
+        if img:
+            # Validate that the image has actual content (not completely empty/black)
+            try:
+                extrema = img.getextrema()
+                if isinstance(extrema[0], tuple):
+                    is_empty = all(e[0] == e[1] for e in extrema)
+                else:
+                    is_empty = extrema[0] == extrema[1]
+                
+                if not is_empty:
+                    return source if return_source_dict else img
+                else:
+                    logger.debug(f"Source '{found_source_name}' returned an empty image, trying next source")
+            except Exception as e:
+                logger.warning(f"Failed to validate image from source '{found_source_name}': {e}")
+                # If validation fails, still return the image as it might be valid
+                return source if return_source_dict else img
+    
+    logger.error("No active source with valid image data found.")
     return None
 
     
@@ -817,7 +946,7 @@ def set_fit_to_screen_for_scene_items(scene_name: str):
                     'positionX': 0, 'positionY': 0,
                 }
                 
-                if not already_cropped:
+                if not True:
                     fit_to_screen_transform.update({
                         'cropLeft': 0 if not aspect_ratio_different or canvas_width > source_width else (source_width - canvas_width) // 2,
                         'cropRight': 0 if not aspect_ratio_different or canvas_width > source_width else (source_width - canvas_width) // 2,
@@ -915,6 +1044,13 @@ def create_scene():
 if __name__ == '__main__':
     logging.basicConfig(level=logging.INFO)
     connect_to_obs_sync()
+    try:
+        with connection_pool.get_client() as client:
+            client: obs.ReqClient
+            resp = client.get_scene_item_list(get_current_scene())
+            print(resp.scene_items)
+    except Exception as e:
+        print(f"Error: {e}")
     
     # outputs = get_output_list()
     # print(outputs)

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -54,8 +54,11 @@ class ScreenSelector:
             raise RuntimeError("mss is required for screen selection.")
 
         if self.use_obs_screenshot:
-            print("Using OBS screenshot as target.")
-            self.screenshot_img = obs.get_screenshot_PIL(compression=75)
+            sources = obs.get_active_video_sources()
+            best_source = obs.get_best_source_for_screenshot()
+            if len(sources) > 1:
+                logger.warning(f"Warning: Multiple active video sources found in OBS. Using '{best_source.get('sourceName')}' for screenshot. Please ensure only one source is active for best results.")
+            self.screenshot_img = obs.get_screenshot_PIL(compression=100, img_format='jpg')
             # print(screenshot_base64)
             if not self.screenshot_img:
                 raise RuntimeError("Failed to get OBS screenshot.")

GameSentenceMiner/ocr/owocr_helper.py

@@ -391,7 +391,7 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
                     stable_time = last_meiki_crop_time
                     previous_img_local = previous_img
                     pre_crop_image = previous_img_local
-                    ocr2_image = get_ocr2_image(crop_coords, og_image=previous_img_local, ocr2_engine=get_ocr_ocr2())
+                    ocr2_image = get_ocr2_image(crop_coords, og_image=previous_img_local, ocr2_engine=get_ocr_ocr2(), extra_padding=10)
                     # Use the earlier timestamp for when the stable crop started if available
                     # ocr2_image.show()
                     second_ocr_queue.put((text, stable_time, ocr2_image, filtering, pre_crop_image))
@@ -482,22 +482,54 @@ done = False
 # Create a queue for tasks
 second_ocr_queue = queue.Queue()
 
-def get_ocr2_image(crop_coords, og_image: Image.Image, ocr2_engine=None):
+def get_ocr2_image(crop_coords, og_image: Image.Image, ocr2_engine=None, extra_padding=0):
     """
     Returns the image to use for the second OCR pass, cropping and scaling as needed.
     Logic is unchanged, but code is refactored for clarity and maintainability.
     """
     def return_original_image():
+        """Return a (possibly cropped) PIL.Image based on the original image and padding."""
         logger.debug("Returning original image for OCR2 (no cropping or optimization).")
+        # Convert bytes to PIL.Image if necessary
+        img = og_image
+        if isinstance(og_image, (bytes, bytearray)):
+            try:
+                img = Image.open(io.BytesIO(og_image)).convert('RGB')
+            except Exception:
+                # If conversion fails, just return og_image as-is
+                return og_image
+
         if not crop_coords or not get_ocr_optimize_second_scan():
-            return og_image
+            return img
+
         x1, y1, x2, y2 = crop_coords
-        x1 = min(max(0, x1), og_image.width)
-        y1 = min(max(0, y1), og_image.height)
-        x2 = min(max(0, x2), og_image.width)
-        y2 = min(max(0, y2), og_image.height)
-        og_image.save(os.path.join(get_temporary_directory(), "pre_oneocrcrop.png"))
-        return og_image.crop((x1, y1, x2, y2))
+        # Apply integer padding (can be negative to shrink)
+        pad = int(extra_padding or 0)
+        x1 = x1 - pad
+        y1 = y1 - pad
+        x2 = x2 + pad
+        y2 = y2 + pad
+
+        # Clamp coordinates to image bounds
+        x1 = min(max(0, int(x1)), img.width)
+        y1 = min(max(0, int(y1)), img.height)
+        x2 = min(max(0, int(x2)), img.width)
+        y2 = min(max(0, int(y2)), img.height)
+
+        # Ensure at least a 1-pixel width/height
+        if x2 <= x1:
+            x2 = min(img.width, x1 + 1)
+            x1 = max(0, x2 - 1)
+        if y2 <= y1:
+            y2 = min(img.height, y1 + 1)
+            y1 = max(0, y2 - 1)
+
+        try:
+            img.save(os.path.join(get_temporary_directory(), "pre_oneocrcrop.png"))
+        except Exception:
+            # don't fail just because we couldn't save a debug image
+            logger.debug("Could not save pre_oneocrcrop.png for debugging")
+        return img.crop((x1, y1, x2, y2))
     
     # TODO Get rid of this check, and just always convert to full res
     LOCAL_OCR_ENGINES = ['easyocr', 'oneocr', 'rapidocr', 'mangaocr', 'winrtocr']
@@ -541,16 +573,33 @@ def get_ocr2_image(crop_coords, og_image: Image.Image, ocr2_engine=None):
     x2 = int(crop_coords[2] * width_ratio)
     y2 = int(crop_coords[3] * height_ratio)
 
+    # Scale padding separately for X and Y
+    pad_x = int(round((extra_padding or 0) * width_ratio))
+    pad_y = int(round((extra_padding or 0) * height_ratio))
+
+    x1 = x1 - pad_x
+    y1 = y1 - pad_y
+    x2 = x2 + pad_x
+    y2 = y2 + pad_y
+
     # Clamp coordinates to image bounds
-    x1 = min(max(0, x1), img.width)
-    y1 = min(max(0, y1), img.height)
-    x2 = min(max(0, x2), img.width)
-    y2 = min(max(0, y2), img.height)
-    
+    x1 = min(max(0, int(x1)), img.width)
+    y1 = min(max(0, int(y1)), img.height)
+    x2 = min(max(0, int(x2)), img.width)
+    y2 = min(max(0, int(y2)), img.height)
+
+    # Ensure at least a 1-pixel width/height
+    if x2 <= x1:
+        x2 = min(img.width, x1 + 1)
+        x1 = max(0, x2 - 1)
+    if y2 <= y1:
+        y2 = min(img.height, y1 + 1)
+        y1 = max(0, y2 - 1)
+
     logger.debug(f"Scaled crop coordinates: {(x1, y1, x2, y2)}")
-    
+
     img = run.apply_ocr_config_to_image(img, ocr_config_local, is_secondary=False)
-    
+
     ret = img.crop((x1, y1, x2, y2))
     return ret
 
@@ -763,7 +812,7 @@ if __name__ == "__main__":
             try:
                 while not done:
                     time.sleep(1)
-            except KeyboardInterrupt as e:
+            except KeyboardInterrupt:
                 pass
         else:
             print("Failed to load OCR configuration. Please check the logs.")

GameSentenceMiner/owocr/owocr/run.py

@@ -1038,7 +1038,8 @@ class OBSScreenshotThread(threading.Thread):
     def init_config(self, source=None, scene=None):
         import GameSentenceMiner.obs as obs
         obs.update_current_game()
-        self.current_source = source if source else obs.get_active_source()
+        current_sources = obs.get_active_video_sources()
+        self.current_source = source if source else obs.get_best_source_for_screenshot()
         logger.debug(f"Current OBS source: {self.current_source}")
         self.source_width = self.current_source.get(
             "sceneItemTransform").get("sourceWidth") or self.width
@@ -1056,6 +1057,8 @@ class OBSScreenshotThread(threading.Thread):
                 f"Using source dimensions: {self.width}x{self.height}")
         self.current_source_name = self.current_source.get(
             "sourceName") or None
+        if len(current_sources) > 1:
+            logger.error(f"Multiple active video sources found in OBS. Using {self.current_source_name} for Screenshot. Please ensure only one source is active for best results.")
         self.current_scene = scene if scene else obs.get_current_game()
         self.ocr_config = get_scene_ocr_config(refresh=True)
         if not self.ocr_config:
@@ -1394,7 +1397,7 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
     if res:
         if 'provider' in text:
             if write_to == 'callback':
-                logger.opt(ansi=True).info(f"{len(text['boxes'])} text boxes recognized using Meiki:")
+                logger.opt(ansi=True).info(f"{len(text['boxes'])} text boxes recognized in {end_time - start_time:0.03f}s using Meiki:")
                 txt_callback('', '', ocr_start_time,
                              img_or_path, is_second_ocr, filtering, text.get('crop_coords', None), meiki_boxes=text.get('boxes', []))
                 return str(text), str(text)

GameSentenceMiner/ui/config_gui.py

@@ -449,6 +449,7 @@ class ConfigApp:
         self.screenshot_timing_value = tk.StringVar(value=self.settings.screenshot.screenshot_timing_setting)
         self.use_screenshot_selector_value = tk.BooleanVar(value=self.settings.screenshot.use_screenshot_selector)
         self.animated_screenshot_value = tk.BooleanVar(value=self.settings.screenshot.animated)
+        self.trim_black_bars_value = tk.BooleanVar(value=self.settings.screenshot.trim_black_bars_wip)
 
         # Audio Settings
         self.audio_enabled_value = tk.BooleanVar(value=self.settings.audio.enabled)
@@ -703,6 +704,7 @@ class ConfigApp:
                 seconds_after_line=float(self.seconds_after_line_value.get()) if self.seconds_after_line_value.get() else 0.0,
                 screenshot_timing_setting=self.screenshot_timing_value.get(),
                 use_screenshot_selector=self.use_screenshot_selector_value.get(),
+                trim_black_bars_wip=self.trim_black_bars_value.get(),
             ),
             audio=Audio(
                 enabled=self.audio_enabled_value.get(),
@@ -771,6 +773,7 @@ class ConfigApp:
                 use_canned_context_prompt=self.use_canned_context_prompt_value.get(),
                 custom_prompt=self.custom_prompt.get("1.0", tk.END).strip(),
                 dialogue_context_length=int(self.ai_dialogue_context_length_value.get()),
+                custom_texthooker_prompt=self.custom_texthooker_prompt.get("1.0", tk.END).strip(),
             ),
             overlay=Overlay(
                 websocket_port=int(self.overlay_websocket_port_value.get()),
@@ -1765,6 +1768,14 @@ class ConfigApp:
             row=self.current_row, column=1, sticky='W', pady=2)
         self.current_row += 1
 
+        trim_black_bars_i18n = ss_i18n.get('trim_black_bars', {})
+        HoverInfoLabelWidget(screenshot_frame, text=trim_black_bars_i18n.get('label', '...'),
+                             tooltip=trim_black_bars_i18n.get('tooltip', '...'),
+                             row=self.current_row, column=0)
+        ttk.Checkbutton(screenshot_frame, variable=self.trim_black_bars_value, bootstyle="round-toggle").grid(
+            row=self.current_row, column=1, sticky='W', pady=2)
+        self.current_row += 1
+
         self.add_reset_button(screenshot_frame, "screenshot", self.current_row, 0, self.create_screenshot_tab)
 
         for col in range(3):
@@ -2299,6 +2310,16 @@ class ConfigApp:
         self.custom_prompt.insert(tk.END, self.settings.ai.custom_prompt)
         self.custom_prompt.grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
+        
+        custom_texthooker_prompt_i18n = ai_i18n.get('custom_texthooker_prompt', {})
+        HoverInfoLabelWidget(ai_frame, text=custom_texthooker_prompt_i18n.get('label', 'Custom Texthooker Prompt:'), tooltip=custom_texthooker_prompt_i18n.get('tooltip', 'Custom Prompt to use for Texthooker Translate Button.'),
+                             row=self.current_row, column=0)
+        self.custom_texthooker_prompt = scrolledtext.ScrolledText(ai_frame, width=50, height=5, font=("TkDefaultFont", 9),
+                                                                   relief="solid", borderwidth=1,
+                                                                   highlightbackground=ttk.Style().colors.border)
+        self.custom_texthooker_prompt.insert(tk.END, self.settings.ai.custom_texthooker_prompt)
+        self.custom_texthooker_prompt.grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        self.current_row += 1
 
         self.add_reset_button(ai_frame, "ai", self.current_row, 0, self.create_ai_tab)