Magnifier reworks

source/_magnifier/__init__.py

@@ -9,55 +9,116 @@
 """
 
 from typing import TYPE_CHECKING
-from .fullscreenMagnifier import FullScreenMagnifier
+from .config import getMagnifierType
+from .utils.types import MagnifierType
 
 if TYPE_CHECKING:
 	from .magnifier import Magnifier
 
 _magnifier: "Magnifier | None" = None
 
 
-def initialize():
+def createMagnifier(magnifierType: MagnifierType) -> "Magnifier":
 	"""
-	Initialize the magnifier module
-	For now, only the full-screen magnifier is supported
+	Create a magnifier instance based on the specified type.
+
+	:param magnifierType: The type of magnifier to create
+	:return: The created magnifier instance
+	:raises ValueError: If the magnifier type is not supported
+	"""
+
+	match magnifierType:
+		case MagnifierType.FULLSCREEN:
+			from .fullscreenMagnifier import FullScreenMagnifier
+
+			return FullScreenMagnifier()
+
+		case MagnifierType.FIXED:
+			from .placeholderMagnifier import PlaceholderMagnifier
+
+			return PlaceholderMagnifier()
+
+		case MagnifierType.DOCKED:
+			from .placeholderMagnifier import PlaceholderMagnifier
+
+			return PlaceholderMagnifier()
+
+		case MagnifierType.LENS:
+			from .placeholderMagnifier import PlaceholderMagnifier
+
+			return PlaceholderMagnifier()
+
+		case _:
+			raise ValueError(f"Unsupported magnifier type: {magnifierType}")
+
+
+def _setMagnifierType(magnifierType: MagnifierType) -> None:
+	"""
+	Set the magnifier type, stopping the current one if active and creating a new instance.
+
+	:param magnifierType: The type of magnifier to set
 	"""
+	global _magnifier
+
+	# Stop current magnifier if active
+	if _magnifier and _magnifier._isActive:
+		_magnifier._stopMagnifier()
 
-	magnifier = FullScreenMagnifier()
-	setMagnifier(magnifier)
+	# Create and set new magnifier instance
+	_magnifier = createMagnifier(magnifierType)
+
+
+def initialize() -> None:
+	"""
+	Initialize the magnifier module with the default magnifier type from config.
+	"""
+	magnifierType = getMagnifierType()
+	_setMagnifierType(magnifierType)
+	_magnifier._startMagnifier()
 
 
 def isActive() -> bool:
 	"""
-	Check if magnifier is currently active for settings
+	Check if magnifier is currently active.
+
+	:return: True if magnifier is active, False otherwise
 	"""
 	global _magnifier
-	return _magnifier and _magnifier._isActive
+	return _magnifier is not None and _magnifier._isActive
 
 
-def getMagnifier() -> "Magnifier | None":
+def changeMagnifierType(magnifierType: MagnifierType) -> None:
 	"""
-	Get current magnifier
+	Change the magnifier type at runtime.
+	Stops the current magnifier and starts a new one of the specified type.
+
+	:param magnifierType: The new magnifier type to use
+	:raises RuntimeError: If no magnifier is currently active
 	"""
 	global _magnifier
-	return _magnifier
+	if not _magnifier or not _magnifier._isActive:
+		raise RuntimeError("Cannot change magnifier type: magnifier is not active")
 
+	_setMagnifierType(magnifierType)
+	_magnifier._startMagnifier()
 
-def setMagnifier(magnifier: "Magnifier") -> None:
+
+def getMagnifier() -> "Magnifier | None":
 	"""
-	Set magnifier instance
+	Get the current magnifier instance.
 
-	:param magnifier: The magnifier instance to set
+	:return: The current magnifier instance, or None if not initialized
 	"""
 	global _magnifier
-	_magnifier = magnifier
+	return _magnifier
 
 
-def terminate():
+def terminate() -> None:
 	"""
-	Called when NVDA shuts down
+	Terminate the magnifier module.
+	Called when NVDA shuts down.
 	"""
 	global _magnifier
 	if _magnifier and _magnifier._isActive:
 		_magnifier._stopMagnifier()
-		_magnifier = None
+	_magnifier = None

source/_magnifier/commands.py

@@ -10,12 +10,17 @@
 
 from typing import Literal
 import ui
-from . import getMagnifier, initialize, terminate
+from . import getMagnifier, initialize, changeMagnifierType, terminate
 from .config import (
-	getDefaultZoomLevelString,
-	getDefaultFilter,
-	getDefaultFullscreenMode,
 	ZoomLevel,
+	getZoomLevelString,
+	setZoomLevel,
+	getFilter,
+	setFilter,
+	getMagnifierType,
+	setMagnifierType,
+	getFullscreenMode,
+	setFullscreenMode,
 )
 from .magnifier import Magnifier
 from .fullscreenMagnifier import FullScreenMagnifier
@@ -100,20 +105,34 @@ def toggleMagnifier() -> None:
 	else:
 		initialize()
 
-		filter = getDefaultFilter()
-		fullscreenMode = getDefaultFullscreenMode()
-
-		ui.message(
-			pgettext(
-				"magnifier",
-				# Translators: Message announced when starting the NVDA magnifier.
-				"Starting magnifier with {zoomLevel} zoom level, {filter} filter, and {fullscreenMode} full-screen mode",
-			).format(
-				zoomLevel=getDefaultZoomLevelString(),
-				filter=filter.displayString,
-				fullscreenMode=fullscreenMode.displayString,
-			),
-		)
+		filter = getFilter()
+		magnifierType = getMagnifierType()
+		if magnifierType == MagnifierType.FULLSCREEN:
+			fullscreenMode = getFullscreenMode()
+			ui.message(
+				pgettext(
+					"magnifier",
+					# Translators: Message announced when starting the NVDA magnifier.
+					"Starting fullscreen magnifier with {zoomLevel} zoom level, {filter} filter, and {fullscreenMode} full-screen mode",
+				).format(
+					magnifierType=magnifierType.displayString,
+					zoomLevel=getZoomLevelString(),
+					filter=filter.displayString,
+					fullscreenMode=fullscreenMode.displayString,
+				),
+			)
+		else:
+			ui.message(
+				pgettext(
+					"magnifier",
+					# Translators: Message announced when starting the NVDA magnifier.
+					"Starting {magnifierType} magnifier with {zoomLevel} zoom level and {filter} filter",
+				).format(
+					magnifierType=magnifierType.displayString,
+					zoomLevel=getZoomLevelString(),
+					filter=filter.displayString,
+				),
+			)
 
 
 def zoom(direction: Direction) -> None:
@@ -126,6 +145,7 @@ def zoom(direction: Direction) -> None:
 	magnifier: Magnifier = getMagnifier()
 	if magnifierIsActiveVerify(magnifier, action):
 		magnifier._zoom(direction)
+		setZoomLevel(magnifier.zoomLevel)
 		ui.message(
 			ZoomLevel.ZOOM_MESSAGE.format(
 				zoomLevel=f"{magnifier.zoomLevel:.1f}",
@@ -153,7 +173,31 @@ def pan(action: MagnifierAction) -> None:
 			)
 
 
-def toggleFilter() -> None:
+def cycleMagnifierType() -> None:
+	"""Cycle through magnifier types (full-screen, fixed, docked (to do), lens (to do))"""
+	magnifier: Magnifier = getMagnifier()
+	if magnifierIsActiveVerify(
+		magnifier,
+		MagnifierAction.CHANGE_MAGNIFIER_TYPE,
+	):
+		types = list(MagnifierType)
+		currentType = magnifier._magnifierType
+		idx = types.index(currentType)
+		newType = types[(idx + 1) % len(types)]
+		log.debug(f"Changing magnifier type from {currentType} to {newType}")
+		changeMagnifierType(newType)
+		setMagnifierType(newType)
+		magnifier = getMagnifier()
+		ui.message(
+			pgettext(
+				"magnifier",
+				# Translators: Message announced when changing the magnifier type with {type} being the new magnifier type.
+				"Magnifier type changed to {type}",
+			).format(type=magnifier._magnifierType.displayString),
+		)
+
+
+def cycleFilter() -> None:
 	"""Cycle through color filters"""
 	magnifier: Magnifier = getMagnifier()
 	log.debug(f"Toggling filter for magnifier: {magnifier}")
@@ -166,6 +210,7 @@ def toggleFilter() -> None:
 		magnifier.filterType = filters[(idx + 1) % len(filters)]
 		if magnifier._magnifierType == MagnifierType.FULLSCREEN:
 			magnifier._applyFilter()
+		setFilter(magnifier.filterType)
 		ui.message(
 			pgettext(
 				"magnifier",
@@ -175,7 +220,7 @@ def toggleFilter() -> None:
 		)
 
 
-def toggleFullscreenMode() -> None:
+def cycleFullscreenMode() -> None:
 	"""Cycle through full-screen focus modes (center, border, relative)"""
 	magnifier: Magnifier = getMagnifier()
 	if magnifierIsActiveVerify(
@@ -192,6 +237,7 @@ def toggleFullscreenMode() -> None:
 			newMode = modes[(idx + 1) % len(modes)]
 			log.debug(f"Changing full-screen mode from {currentMode} to {newMode}")
 			magnifier._fullscreenMode = newMode
+			setFullscreenMode(newMode)
 			ui.message(
 				pgettext(
 					"magnifier",