frontengine 1.0.44__tar.gz → 1.0.46__tar.gz

{frontengine-1.0.44 → frontengine-1.0.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: frontengine
-Version: 1.0.44
+Version: 1.0.46
 Summary: FrontEngine is use-define frontview or only use like screen saver
 Author-email: JE-Chen <jechenmailman@gmail.com>
 Project-URL: Homepage, https://github.com/Intergration-Automation-Testing/FrontEngine
@@ -196,6 +196,28 @@ Four things on the **Stream** tab, for playing and for going live:
 
 ---
 
+## Screen-sharing privacy
+
+Your overlays are for you, not for the people you are sharing with. From
+**Settings → Screen-sharing privacy**, FrontEngine can take them out of the
+capture while a meeting app is open:
+
+- **They stay on your own screen.** Only the captured copy is blank — this uses
+  Windows' `WDA_EXCLUDEFROMCAPTURE`, an OS-level flag that conferencing apps and
+  recorders honour.
+- **Masks are the exception.** A distraction mask exists to cover something, so
+  it deliberately stays visible in the capture.
+- **The trigger is your list.** Windows has no dependable "am I being captured"
+  API, so it watches for window titles you name — which also catches a meeting
+  held in a browser tab, where the executable is just the browser.
+
+There is a manual **Hide from capture** button in the control center too.
+
+> This is privacy, not security: it defeats the ordinary capture path, and it
+> never hides anything from the person sitting at the desk. Windows only.
+
+---
+
 ## Screen time, clipboard and layouts
 
 Three things that remember, all of them **off until you switch them on** and

{frontengine-1.0.44 → frontengine-1.0.46}/README.md

@@ -172,6 +172,28 @@ Four things on the **Stream** tab, for playing and for going live:
 
 ---
 
+## Screen-sharing privacy
+
+Your overlays are for you, not for the people you are sharing with. From
+**Settings → Screen-sharing privacy**, FrontEngine can take them out of the
+capture while a meeting app is open:
+
+- **They stay on your own screen.** Only the captured copy is blank — this uses
+  Windows' `WDA_EXCLUDEFROMCAPTURE`, an OS-level flag that conferencing apps and
+  recorders honour.
+- **Masks are the exception.** A distraction mask exists to cover something, so
+  it deliberately stays visible in the capture.
+- **The trigger is your list.** Windows has no dependable "am I being captured"
+  API, so it watches for window titles you name — which also catches a meeting
+  held in a browser tab, where the executable is just the browser.
+
+There is a manual **Hide from capture** button in the control center too.
+
+> This is privacy, not security: it defeats the ordinary capture path, and it
+> never hides anything from the person sitting at the desk. Windows only.
+
+---
+
 ## Screen time, clipboard and layouts
 
 Three things that remember, all of them **off until you switch them on** and

{frontengine-1.0.44 → frontengine-1.0.46}/frontengine/show/base_widget.py

@@ -33,6 +33,12 @@ class BaseWidget(QWidget):
         # 畫質檔位：影響更新頻率上限與算圖縮放（見 utils/power_mode）
         # Quality tier: caps the refresh rate and scales rendering (see utils/power_mode).
         self.quality_tier: str = DEFAULT_TIER
+        # 分享畫面時要不要一起藏起來。遮蔽用的覆蓋層要留在畫面上——
+        # 那正是它存在的理由，藏了就等於沒遮。
+        # Whether this hides along with the others while sharing. A masking
+        # overlay must stay visible in the capture: hiding it would defeat
+        # the only thing it is for.
+        self.keep_in_capture: bool = False
         self._drag_origin = None
         self._geometry_restored = False
 

{frontengine-1.0.44 → frontengine-1.0.46}/frontengine/show/focus_shield/focus_shield_widget.py

@@ -118,6 +118,9 @@ class DistractionMaskWidget(BaseWidget):
             f"[DistractionMaskWidget] Init | region={region}, percent={percent}")
         super().__init__()
         self.opacity = 1.0
+        # 這一層是拿來遮住東西的，分享畫面時必須留在擷取結果裡
+        # This layer exists to cover something, so it stays in the capture.
+        self.keep_in_capture = True
         self.region = region
         self.percent = clamp_percent(percent)
         self.mask_color = QColor(color) if QColor(color).isValid() else QColor("#101010")

{frontengine-1.0.44 → frontengine-1.0.46}/frontengine/show/particle/particle_ui.py

@@ -107,40 +107,39 @@ class ParticleOpenGLWidget(QOpenGLWidget):
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
 
-    def update_particles(self):
-        for p in self.particles:
-            x, y = p
-            if self.particle_direction == "down":
-                y -= self.particle_speed
-                if y < -1:
-                    y = 1
-                    x = random.uniform(-1, 1)
-
-            elif self.particle_direction == "up":
-                y += self.particle_speed
-                if y > 1:
-                    y = -1
-                    x = random.uniform(-1, 1)
-
-            elif self.particle_direction == "left":
-                x -= self.particle_speed
-                if x < -1:
-                    x = 1
-                    y = random.uniform(-1, 1)
-
-            elif self.particle_direction == "right":
-                x += self.particle_speed
-                if x > 1:
-                    x = -1
-                    y = random.uniform(-1, 1)
-
-            # 你可以自行擴充其他方向
-
-            p[0] = x
-            p[1] = y
+    # 每個方向：(要移動的軸, 每步的位移正負, 越過哪一邊算離場)
+    # Per direction: which axis moves, the sign of each step, and which edge
+    # counts as leaving the screen.
+    _DIRECTIONS = {
+        "down": (1, -1, -1.0),
+        "up": (1, +1, +1.0),
+        "left": (0, -1, -1.0),
+        "right": (0, +1, +1.0),
+    }
 
+    def update_particles(self):
+        """把每個粒子往設定的方向推一步，離開畫面的就從對面重新進場。"""
+        movement = self._DIRECTIONS.get(self.particle_direction)
+        if movement is None:
+            self.update()
+            return
+        axis, sign, edge = movement
+        other = 1 - axis
+        for particle in self.particles:
+            particle[axis] += sign * self.particle_speed
+            if self._left_the_screen(particle[axis], sign, edge):
+                # 從對面邊緣回來，另一軸重新隨機，看起來才像源源不絕
+                # Re-enter from the opposite edge with a fresh position on the
+                # other axis, so the stream never looks like a repeating loop.
+                particle[axis] = -edge
+                particle[other] = random.uniform(-1, 1)  # nosec B311 - visual only
         self.update()
 
+    @staticmethod
+    def _left_the_screen(value: float, sign: int, edge: float) -> bool:
+        """這個粒子是不是已經越過它前進方向的那一邊。"""
+        return value < edge if sign < 0 else value > edge
+
     def paintGL(self):
         glClearColor(0, 0, 0, 0)
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

{frontengine-1.0.44 → frontengine-1.0.46}/frontengine/show/pet/desktop_pet.py

@@ -806,7 +806,15 @@ class PetMotion:
         if self.surface != SURFACE_FLOOR:
             return self._step_climb(left, top, right, bottom, floor_y)
 
-        # grounded on the screen floor: random walk / idle, with a chance to climb a wall
+        return self._walk_on_floor(left, right, floor_y)
+
+    def _walk_on_floor(self, left, right, floor_y) -> Tuple[int, int]:
+        """
+        站在螢幕地板上：隨機在走路與發呆之間切換，走到左右邊緣時有機會改成
+        爬牆，否則就轉頭。
+        Grounded on the screen floor: alternate between walking and idling, and
+        on reaching an edge either grab the wall or turn around.
+        """
         self.y = float(floor_y)
         if self._state_ticks <= 0:
             self._new_state()
@@ -816,20 +824,20 @@ class PetMotion:
         self.x += self.vx
         if self.x <= left:
             self.x = float(left)
-            if self.climb and self._rng.random() < self.CLIMB_CHANCE:
-                self.surface = SURFACE_LEFT
-                self.vy = float(-self.speed)
-            else:
-                self.vx = abs(self.vx)
+            self._turn_or_climb(SURFACE_LEFT, turned_vx=abs(self.vx))
         elif self.x + self.width >= right:
             self.x = float(right - self.width)
-            if self.climb and self._rng.random() < self.CLIMB_CHANCE:
-                self.surface = SURFACE_RIGHT
-                self.vy = float(-self.speed)
-            else:
-                self.vx = -abs(self.vx)
+            self._turn_or_climb(SURFACE_RIGHT, turned_vx=-abs(self.vx))
         return int(self.x), int(self.y)
 
+    def _turn_or_climb(self, wall: str, turned_vx: float) -> None:
+        """走到邊緣了：抓上牆去爬，或是掉頭往回走。"""
+        if self.climb and self._rng.random() < self.CLIMB_CHANCE:
+            self.surface = wall
+            self.vy = float(-self.speed)
+        else:
+            self.vx = turned_vx
+
     def _step_fall(self, left, top, right, bottom, _floor_y) -> Tuple[int, int]:
         """落下：撞牆/天花板反彈，並在越過視窗平台或螢幕地板時落地。"""
         prev_feet = self.y + self.height
@@ -948,42 +956,49 @@ class PetMotion:
             return int(self.x), int(self.y)
 
         if self.surface == SURFACE_RIGHT:
-            self.x = float(right - self.width)
-            self.y += self.vy
-            if self.vy < 0 and self.y <= top:            # reached the ceiling, crawl left
-                self.y = float(top)
-                self.surface = SURFACE_CEILING
-                self.vx = float(-self.speed)
-            elif self.vy > 0 and self.y >= floor_y:      # climbed back down
-                self.y = float(floor_y)
-                self.surface = SURFACE_FLOOR
-                self.vx = float(-self.speed)
-                self._new_state(force_walk=True)
+            # 右牆：貼著右緣上下爬，離開時往左走
+            # Right wall: hug the right edge, and leave it heading left.
+            self._climb_wall(x=float(right - self.width), top=top, floor_y=floor_y,
+                             leave_vx=float(-self.speed))
         elif self.surface == SURFACE_LEFT:
-            self.x = float(left)
-            self.y += self.vy
-            if self.vy < 0 and self.y <= top:
-                self.y = float(top)
-                self.surface = SURFACE_CEILING
-                self.vx = float(self.speed)
-            elif self.vy > 0 and self.y >= floor_y:
-                self.y = float(floor_y)
-                self.surface = SURFACE_FLOOR
-                self.vx = float(self.speed)
-                self._new_state(force_walk=True)
+            self._climb_wall(x=float(left), top=top, floor_y=floor_y,
+                             leave_vx=float(self.speed))
         elif self.surface == SURFACE_CEILING:
-            self.y = float(top)
-            self.x += self.vx
-            if self.vx < 0 and self.x <= left:           # corner -> climb down the left wall
-                self.x = float(left)
-                self.surface = SURFACE_LEFT
-                self.vy = float(self.speed)
-            elif self.vx > 0 and self.x + self.width >= right:
-                self.x = float(right - self.width)
-                self.surface = SURFACE_RIGHT
-                self.vy = float(self.speed)
+            self._crawl_ceiling(left, top, right)
         return int(self.x), int(self.y)
 
+    def _climb_wall(self, x: float, top: float, floor_y: float, leave_vx: float) -> None:
+        """
+        沿著一面牆上下爬。左右兩面牆的規則一模一樣，只差「離開時往哪走」，
+        所以由呼叫端把那個方向帶進來。
+        Climb one wall. Both walls follow identical rules and differ only in
+        which way the pet leaves, so the caller passes that in.
+        """
+        self.x = x
+        self.y += self.vy
+        if self.vy < 0 and self.y <= top:            # 到天花板，改成橫著爬
+            self.y = float(top)
+            self.surface = SURFACE_CEILING
+            self.vx = leave_vx
+        elif self.vy > 0 and self.y >= floor_y:      # 爬回地面，恢復走路
+            self.y = float(floor_y)
+            self.surface = SURFACE_FLOOR
+            self.vx = leave_vx
+            self._new_state(force_walk=True)
+
+    def _crawl_ceiling(self, left, top, right) -> None:
+        """在天花板上橫著爬，到角落就轉成往下爬那面牆。"""
+        self.y = float(top)
+        self.x += self.vx
+        if self.vx < 0 and self.x <= left:
+            self.x = float(left)
+            self.surface = SURFACE_LEFT
+            self.vy = float(self.speed)
+        elif self.vx > 0 and self.x + self.width >= right:
+            self.x = float(right - self.width)
+            self.surface = SURFACE_RIGHT
+            self.vy = float(self.speed)
+
     def _new_state(self, force_walk: bool = False) -> None:
         if force_walk or self._rng.random() < 0.65:
             self.state = "walk"
@@ -1245,25 +1260,42 @@ class DesktopPetWidget(BaseWidget):
             self._peer_greeted = False
             self.motion.clear_follow()
             return
-        # play: a floor pet may walk over to a near-ish peer
-        if self.motion.behaviour == BEHAVIOUR_FLOOR:
-            if self.MEET_DISTANCE < distance <= self.PLAY_RANGE:
-                if self.motion.follow_target_x is not None or self._chatter_rng.random() < self.PLAY_CHANCE:
-                    self.motion.set_follow(peer[0])
-            elif distance > self.PLAY_RANGE:
-                self.motion.clear_follow()
-        # greet: face and say a meet line once per approach
-        if distance <= self.MEET_DISTANCE:
+        self._approach_peer(peer, distance)
+        self._greet_peer(peer, distance, my_center)
+
+    def _approach_peer(self, peer, distance: float) -> None:
+        """在地板上的寵物看到不遠的同伴時，有機會走過去玩。"""
+        if self.motion.behaviour != BEHAVIOUR_FLOOR:
+            return
+        if self.MEET_DISTANCE < distance <= self.PLAY_RANGE:
+            already_walking = self.motion.follow_target_x is not None
+            if already_walking or self._chatter_rng.random() < self.PLAY_CHANCE:
+                self.motion.set_follow(peer[0])
+        elif distance > self.PLAY_RANGE:
             self.motion.clear_follow()
-            if self._talk and not self._peer_greeted:
-                self._peer_greeted = True
-                self._gain_affection(3)
-                self.motion.vx = abs(self.motion.vx) if peer[0] >= my_center[0] else -abs(self.motion.vx)
-                pool = self._messages.get("meet") or []
-                if pool:
-                    self.say(pool[self._chatter_rng.randrange(len(pool))])
-        elif distance > self.MEET_DISTANCE * 1.6:
-            self._peer_greeted = False
+
+    def _greet_peer(self, peer, distance: float, my_center) -> None:
+        """
+        走到夠近就轉頭打個招呼，一次接近只打一次；離開夠遠之後才會重新算一次
+        （這段遲滯是為了避免在邊界來回時一直重複講話）。
+        Close enough: turn to face them and say hello, once per approach. The
+        flag only resets once they are well clear again, which stops a pet
+        hovering at the boundary from repeating itself.
+        """
+        if distance > self.MEET_DISTANCE:
+            if distance > self.MEET_DISTANCE * 1.6:
+                self._peer_greeted = False
+            return
+        self.motion.clear_follow()
+        if not self._talk or self._peer_greeted:
+            return
+        self._peer_greeted = True
+        self._gain_affection(3)
+        self.motion.vx = (abs(self.motion.vx) if peer[0] >= my_center[0]
+                          else -abs(self.motion.vx))
+        pool = self._messages.get("meet") or []
+        if pool:
+            self.say(pool[self._chatter_rng.randrange(len(pool))])
 
     def _load_sprite(self, path: str):
         """載入一張精靈；檔案損毀或格式不支援時回傳 None。"""

frontengine-1.0.46/frontengine/ui/dialog/screen_privacy_dialog.py

@@ -0,0 +1,98 @@
+"""
+螢幕分享隱私設定：偵測到會議程式時，自動把覆蓋層藏出擷取畫面。
+
+Windows 沒有可靠的「我正在被擷取嗎」API，所以判斷依據是使用者自己列出的
+會議程式有沒有開著視窗。這是刻意的：與其猜錯，不如讓使用者說了算。
+
+Screen-sharing privacy: hide the overlays from the capture when a meeting app
+turns up.
+
+Windows offers no dependable "am I being captured" API, so the trigger is
+whether one of the apps the user listed has a window open. That is deliberate -
+better their list than our guess.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from PySide6.QtWidgets import (
+    QCheckBox, QDialog, QDialogButtonBox, QGridLayout, QLabel, QLineEdit, QWidget,
+)
+
+from frontengine.user_setting.user_setting_file import user_setting_dict, write_user_setting
+from frontengine.utils.logging.loggin_instance import front_engine_logger
+from frontengine.utils.multi_language.language_wrapper import language_wrapper
+from frontengine.utils.screen_privacy import capture_affinity
+from frontengine.utils.screen_privacy.share_watch import DEFAULT_SHARING_APPS
+from frontengine.utils.smart_pause.pause_rules import parse_app_list
+
+SETTING_KEY = "screen_share_privacy"
+DEFAULT_SETTINGS: Dict[str, Any] = {"enabled": False, "apps": list(DEFAULT_SHARING_APPS)}
+
+
+def _t(key: str, fallback: str) -> str:
+    return language_wrapper.language_word_dict.get(key, fallback)
+
+
+def current_settings() -> Dict[str, Any]:
+    """目前的分享隱私設定（缺項目補預設值）。"""
+    stored = user_setting_dict.get(SETTING_KEY)
+    settings = dict(DEFAULT_SETTINGS)
+    if isinstance(stored, dict):
+        settings.update({key: stored[key] for key in DEFAULT_SETTINGS if key in stored})
+    settings["apps"] = parse_app_list(settings.get("apps")) or list(DEFAULT_SHARING_APPS)
+    return settings
+
+
+class ScreenPrivacyDialog(QDialog):
+    """設定哪些程式算是「正在分享」，以及要不要自動隱藏。"""
+
+    def __init__(self, parent: Optional[QWidget] = None) -> None:
+        front_engine_logger.info("[ScreenPrivacyDialog] Init")
+        super().__init__(parent)
+        self.setWindowTitle(_t("screen_privacy_title", "Screen-sharing privacy"))
+        settings = current_settings()
+
+        self.enable_checkbox = QCheckBox(
+            _t("screen_privacy_enable", "Hide overlays while one of these apps is open"))
+        self.enable_checkbox.setChecked(bool(settings.get("enabled")))
+        self.apps_label = QLabel(_t("screen_privacy_apps_label", "Meeting and capture apps:"))
+        self.apps_edit = QLineEdit(", ".join(settings.get("apps", [])))
+        self.apps_edit.setPlaceholderText("zoom, teams, discord")
+        self.hint_label = QLabel(
+            _t("screen_privacy_hint",
+               "Matched against window titles, so a meeting held in a browser tab is caught "
+               "too. Your overlays stay on your own screen - only the capture is blank. "
+               "Masks stay visible, since covering something is what they are for.")
+            if capture_affinity.available() else
+            _t("screen_privacy_unsupported",
+               "Hiding overlays from screen capture is Windows only."))
+        self.hint_label.setWordWrap(True)
+
+        self.button_box = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
+        self.button_box.accepted.connect(self.accept)
+        self.button_box.rejected.connect(self.reject)
+
+        layout = QGridLayout(self)
+        layout.addWidget(self.enable_checkbox, 0, 0, 1, 2)
+        layout.addWidget(self.apps_label, 1, 0, 1, 2)
+        layout.addWidget(self.apps_edit, 2, 0, 1, 2)
+        layout.addWidget(self.hint_label, 3, 0, 1, 2)
+        layout.addWidget(self.button_box, 4, 0, 1, 2)
+        for widget in (self.enable_checkbox, self.apps_edit):
+            widget.setEnabled(capture_affinity.available())
+
+    def settings(self) -> Dict[str, Any]:
+        """對話框上目前的設定。"""
+        return {
+            "enabled": self.enable_checkbox.isChecked(),
+            "apps": parse_app_list(self.apps_edit.text()) or list(DEFAULT_SHARING_APPS),
+        }
+
+    def accept(self) -> None:
+        settings = self.settings()
+        user_setting_dict[SETTING_KEY] = settings
+        write_user_setting()
+        front_engine_logger.info(f"[ScreenPrivacyDialog] saved | {settings}")
+        super().accept()

{frontengine-1.0.44 → frontengine-1.0.46}/frontengine/ui/main_ui.py

@@ -49,7 +49,9 @@ from frontengine.utils.logging.loggin_instance import front_engine_logger
 from frontengine.utils.multi_language.language_wrapper import language_wrapper
 from frontengine.utils.plugins.plugin_loader import load_plugins
 from frontengine.utils.preset_schedule.preset_schedule_service import PresetScheduleService
+from frontengine.ui.dialog.screen_privacy_dialog import current_settings as current_privacy_settings
 from frontengine.ui.dialog.smart_pause_dialog import current_rules
+from frontengine.utils.screen_privacy.share_watch import ShareWatchService
 from frontengine.utils.app_profile.app_profile_service import AppProfileService
 from frontengine.utils.clipboard.clipboard_history import DEFAULT_LIMIT, ClipboardHistory
 from frontengine.utils.clipboard.clipboard_watcher import ClipboardWatcher
@@ -209,6 +211,12 @@ class FrontEngineMainUI(QMainWindow):
         )
         self.app_profile_service.start()
 
+        # 分享畫面時把覆蓋層藏出擷取結果（自己仍看得到）
+        # Hide the overlays from the capture while sharing; they stay on screen here.
+        self.share_watch_service = ShareWatchService(config_provider=current_privacy_settings)
+        self.share_watch_service.sharing_changed.connect(self._on_sharing_changed)
+        self.share_watch_service.start()
+
         # 使用時間統計：預設關閉，只寫本機檔案，使用者可隨時清除
         # Usage tracking: off by default, local file only, clearable at any time.
         self.usage_tracker = UsageTracker(JsonRepository(Path(getcwd()) / USAGE_FILE))
@@ -460,6 +468,22 @@ class FrontEngineMainUI(QMainWindow):
             self.control_center_ui.show_all()
             self._smart_pause_hid = False
 
+    def _on_sharing_changed(self, sharing: bool, match: str) -> None:
+        """
+        偵測到會議程式開著／關掉時，自動把覆蓋層藏出擷取結果或放回去。
+        遮蔽用的覆蓋層不受影響——它們本來就是要被看到的。
+        Hide the overlays from the capture when a meeting app appears, and put
+        them back when it goes. Masking overlays are left alone: being seen is
+        the whole point of them.
+        """
+        front_engine_logger.info(
+            f"[MainUI] screen sharing={sharing}" + (f" | {match}" if match else ""))
+        self.control_center_ui.set_hide_from_capture(sharing)
+        if sharing:
+            self._last_toast = show_toast(
+                language_wrapper.language_word_dict.get(
+                    "screen_privacy_toast", "Overlays hidden from screen capture"))
+
     def _show_reminder(self, label: str) -> None:
         """提醒到期：在畫面上方顯示一張會自己消失的提示卡。"""
         front_engine_logger.info(f"[MainUI] reminder | {label}")
@@ -526,6 +550,8 @@ class FrontEngineMainUI(QMainWindow):
             self.tools_setting_ui.stop_camera()
         if getattr(self, "stream_setting_ui", None) is not None:
             self.stream_setting_ui.soundboard.stop_all()
+        if getattr(self, "share_watch_service", None) is not None:
+            self.share_watch_service.stop()
         if getattr(self, "reminder_service", None) is not None:
             self.reminder_service.stop()
         if getattr(self, "app_profile_service", None) is not None:

{frontengine-1.0.44 → frontengine-1.0.46}/frontengine/ui/menu/settings_menu.py

@@ -10,6 +10,7 @@ from frontengine.ui.dialog.app_profile_dialog import AppProfileDialog
 from frontengine.ui.dialog.clipboard_dialog import ClipboardDialog
 from frontengine.ui.dialog.hotkey_settings_dialog import HotkeySettingsDialog
 from frontengine.ui.dialog.reminder_dialog import ReminderDialog
+from frontengine.ui.dialog.screen_privacy_dialog import ScreenPrivacyDialog
 from frontengine.ui.dialog.smart_pause_dialog import SmartPauseDialog
 from frontengine.ui.dialog.usage_report_dialog import UsageReportDialog
 from frontengine.user_setting.user_setting_file import (
@@ -87,6 +88,12 @@ def build_settings_menu(ui: "FrontEngineMainUI") -> None:
     menu.addAction(reminder_action)
     ui.reminder_action = reminder_action
 
+    privacy_action = QAction(
+        _t("settings_menu_screen_privacy", "Screen-sharing privacy..."), menu)
+    privacy_action.triggered.connect(lambda: _open_dialog(ui, ScreenPrivacyDialog))
+    menu.addAction(privacy_action)
+    ui.screen_privacy_action = privacy_action
+
     usage_action = QAction(_t("settings_menu_usage", "Screen time..."), menu)
     usage_action.triggered.connect(lambda: _open_usage_dialog(ui))
     menu.addAction(usage_action)

{frontengine-1.0.44 → frontengine-1.0.46}/frontengine/ui/page/control_center/control_center_ui.py

@@ -16,6 +16,7 @@ from frontengine.ui.page.web.web_setting_ui import WEBSettingUI
 from frontengine.user_setting.user_setting_file import clear_overlay_geometry
 from frontengine.utils.logging.loggin_instance import front_engine_logger
 from frontengine.utils.multi_language.language_wrapper import language_wrapper
+from frontengine.utils.screen_privacy import capture_affinity
 from frontengine.utils.power_mode.power_mode import (
     TIER_BALANCED, TIER_HIGH, TIER_SAVER, normalize_tier,
 )
@@ -94,6 +95,10 @@ class ControlCenterUI(QWidget):
         self._extra_overlay_sources: list = []
         self.low_power_button = self._create_button(
             "control_center_low_power_on", self.toggle_low_power)
+        self._hidden_from_capture = False
+        self.capture_button = self._create_button(
+            "control_center_hide_from_capture", self.toggle_hide_from_capture)
+        self.capture_button.setEnabled(capture_affinity.available())
         self.clear_all_button = self._create_button("control_center_close_all", self.clear_all)
 
         # 畫質檔位：比省電模式更細，一次套用到所有覆蓋層
@@ -135,8 +140,9 @@ class ControlCenterUI(QWidget):
         self.grid_layout.addWidget(self.low_power_button, 13, 0)
         self.grid_layout.addWidget(self.quality_label, 14, 0)
         self.grid_layout.addWidget(self.quality_combobox, 15, 0)
-        self.grid_layout.addWidget(self.clear_all_button, 16, 0)
-        self.grid_layout.addWidget(self.log_panel_scroll_area, 0, 1, 17, 1)  # rowSpan covers every button
+        self.grid_layout.addWidget(self.capture_button, 16, 0)
+        self.grid_layout.addWidget(self.clear_all_button, 17, 0)
+        self.grid_layout.addWidget(self.log_panel_scroll_area, 0, 1, 18, 1)  # rowSpan covers every button
         self.setLayout(self.grid_layout)
 
         # Redirect
@@ -353,6 +359,43 @@ class ControlCenterUI(QWidget):
             )
         )
 
+    def set_hide_from_capture(self, hidden: bool) -> int:
+        """
+        分享畫面時把覆蓋層藏起來（自己看得到、對方看不到）。標了
+        keep_in_capture 的覆蓋層不會被藏——遮蔽層本來就是要被看到的。
+        Hide the overlays from screen capture: still visible here, blank for the
+        people you are sharing with. Overlays marked keep_in_capture are left
+        alone, since a mask is meant to be seen.
+        """
+        self._hidden_from_capture = bool(hidden)
+        applied = 0
+
+        def apply(widget) -> None:
+            nonlocal applied
+            if getattr(widget, "keep_in_capture", False):
+                capture_affinity.apply_to_widget(widget, False)
+                return
+            if capture_affinity.apply_to_widget(widget, self._hidden_from_capture):
+                applied += 1
+
+        self._for_each_overlay(apply)
+        front_engine_logger.info(
+            f"ControlCenterUI set_hide_from_capture | hidden={hidden}, applied={applied}")
+        self.capture_button.setText(
+            language_wrapper.language_word_dict.get(
+                "control_center_show_in_capture" if self._hidden_from_capture
+                else "control_center_hide_from_capture",
+                "Show in capture" if self._hidden_from_capture else "Hide from capture"))
+        return applied
+
+    def toggle_hide_from_capture(self) -> None:
+        """切換分享時是否隱藏覆蓋層。"""
+        self.set_hide_from_capture(not self._hidden_from_capture)
+
+    @property
+    def hidden_from_capture(self) -> bool:
+        return self._hidden_from_capture
+
     def toggle_low_power(self) -> None:
         """切換省電模式 / Toggle low-power mode."""
         self.set_low_power(not getattr(self, "_low_power", False))

{frontengine-1.0.44 → frontengine-1.0.46}/frontengine/user_setting/user_setting_file.py

@@ -54,6 +54,9 @@ user_setting_dict: Dict[str, Any] = {
     # Sticky note contents and positions, and whether to reopen them on launch.
     "sticky_notes": [],
     "sticky_notes_restore": False,
+    # 分享畫面時自動把覆蓋層藏出擷取結果（預設關閉）
+    # Hide overlays from the capture while sharing; off by default.
+    "screen_share_privacy": {"enabled": False, "apps": []},
     # 使用時間統計（只寫本機檔案、預設關閉）
     # Usage tracking: local file only, off by default.
     "usage_tracking": False,

{frontengine-1.0.44 → frontengine-1.0.46}/frontengine/utils/multi_language/english.py

@@ -542,4 +542,13 @@ english_word_dict = {
     "stream_obs_record": 'Toggle recording',
     "stream_obs_stream": 'Toggle streaming',
     "stream_hint": 'The crosshair is only drawn on top - no game is modified. OBS control uses its own WebSocket; the password is kept in your local settings.',
+    "control_center_hide_from_capture": 'Hide from capture',
+    "control_center_show_in_capture": 'Show in capture',
+    "settings_menu_screen_privacy": 'Screen-sharing privacy...',
+    "screen_privacy_title": 'Screen-sharing privacy',
+    "screen_privacy_enable": 'Hide overlays while one of these apps is open',
+    "screen_privacy_apps_label": 'Meeting and capture apps:',
+    "screen_privacy_hint": 'Matched against window titles, so a meeting held in a browser tab is caught too. Your overlays stay on your own screen - only the capture is blank. Masks stay visible, since covering something is what they are for.',
+    "screen_privacy_unsupported": 'Hiding overlays from screen capture is Windows only.',
+    "screen_privacy_toast": 'Overlays hidden from screen capture',
 }

{frontengine-1.0.44 → frontengine-1.0.46}/frontengine/utils/multi_language/traditional_chinese.py

@@ -541,4 +541,13 @@ traditional_chinese_word_dict = {
     "stream_obs_record": '切換錄影',
     "stream_obs_stream": '切換直播',
     "stream_hint": '準星只是疊在畫面上的一層，不會更動任何遊戲。OBS 控制走它自己的 WebSocket，密碼只留在本機設定檔裡。',
+    "control_center_hide_from_capture": '分享時隱藏',
+    "control_center_show_in_capture": '分享時顯示',
+    "settings_menu_screen_privacy": '螢幕分享隱私…',
+    "screen_privacy_title": '螢幕分享隱私',
+    "screen_privacy_enable": '這些程式開著時，把覆蓋層藏出擷取畫面',
+    "screen_privacy_apps_label": '會議與擷取程式：',
+    "screen_privacy_hint": '比對的是視窗標題，所以在瀏覽器分頁裡開的會議也抓得到。覆蓋層仍會顯示在你自己的螢幕上，只有擷取畫面那一份是空的。遮蔽層不會被藏起來——遮住東西正是它存在的理由。',
+    "screen_privacy_unsupported": '把覆蓋層藏出螢幕擷取僅支援 Windows。',
+    "screen_privacy_toast": '已把覆蓋層藏出螢幕擷取',
 }