from __future__ import annotations
import math
import FreeCAD
FEATURE = "gizmo"
BACKEND = "ferrocad"
PREFERENCES = "User parameter:BaseApp/Preferences/Mods/%s/%s" % (FEATURE, BACKEND)
DEFAULT_ENABLED = True
DEFAULT_ACTIVE_COLOR = "#38bdf8"
DEFAULT_INACTIVE_COLOR = "#94a3b8"
DEFAULT_SIZE = 80.0
DEFAULT_WIDTH = 1.5
DEFAULT_OPACITY = 1.0
DEFAULT_GHOST_ALPHA = 0.35
DEFAULT_RING_SNAP_DEG = 15.0
DEFAULT_SHOW_READOUT = True
SETTINGS_SCHEMA = (
{
"name": "enabled",
"label": "Show gizmos",
"kind": "bool",
"default": DEFAULT_ENABLED,
},
{
"name": "active_color",
"label": "Active handle",
"kind": "color",
"default": DEFAULT_ACTIVE_COLOR,
},
{
"name": "inactive_color",
"label": "Inactive handle",
"kind": "color",
"default": DEFAULT_INACTIVE_COLOR,
},
{
"name": "size",
"label": "Handle size (px)",
"kind": "float",
"default": DEFAULT_SIZE,
"min": 8.0,
"max": 400.0,
},
{
"name": "width",
"label": "Stroke width (px)",
"kind": "float",
"default": DEFAULT_WIDTH,
"min": 0.5,
"max": 6.0,
},
{
"name": "opacity",
"label": "Opacity",
"kind": "float",
"default": DEFAULT_OPACITY,
"min": 0.0,
"max": 1.0,
},
{
"name": "ghost_alpha",
"label": "Occluded alpha",
"kind": "float",
"default": DEFAULT_GHOST_ALPHA,
"min": 0.0,
"max": 1.0,
},
{
"name": "ring_snap_deg",
"label": "Rotation snap (deg)",
"kind": "float",
"default": DEFAULT_RING_SNAP_DEG,
"min": 0.0,
"max": 180.0,
},
{
"name": "show_readout",
"label": "Show readout",
"kind": "bool",
"default": DEFAULT_SHOW_READOUT,
},
)
GIZMO_SETTINGS_SCHEMA = SETTINGS_SCHEMA
_SPECS = {entry["name"]: entry for entry in SETTINGS_SCHEMA}
_HEX_DIGITS = "0123456789abcdefABCDEF"
def _prefs():
return FreeCAD.ParamGet(PREFERENCES)
def _store(group, spec: dict, value) -> None:
name = spec["name"]
kind = spec["kind"]
if kind == "bool":
group.SetBool(name, bool(value))
elif kind in ("float", "quantity"):
group.SetFloat(name, float(value))
else:
group.SetString(name, str(value))
def _read(spec: dict):
group = _prefs()
name = spec["name"]
kind = spec["kind"]
default = spec["default"]
if kind == "bool":
return group.GetBool(name, bool(default))
if kind in ("float", "quantity"):
return group.GetFloat(name, float(default))
return group.GetString(name, str(default))
def _write(spec: dict, value) -> None:
_store(_prefs(), spec, value)
def _colour(value) -> str:
if not isinstance(value, str):
raise ValueError("a gizmo colour must be a '#rrggbb' string, got %r" % (value,))
text = value.strip()
if not text.startswith("#"):
raise ValueError("a gizmo colour must start with '#', got %r" % (text,))
digits = text[1:]
if len(digits) == 3:
digits = "".join(digit * 2 for digit in digits)
elif len(digits) != 6:
raise ValueError("a gizmo colour must be #rgb or #rrggbb, got %r" % (text,))
if any(digit not in _HEX_DIGITS for digit in digits):
raise ValueError("a gizmo colour has a non-hex digit, got %r" % (text,))
return "#" + digits.lower()
def _number(value, name: str, *, minimum=0.0, maximum=None) -> float:
try:
number = float(value)
except (TypeError, ValueError):
raise ValueError("%s must be a number, got %r" % (name, value)) from None
if not math.isfinite(number):
raise ValueError("%s must be finite, got %r" % (name, value))
if number < minimum:
raise ValueError("%s must be at least %s, got %r" % (name, minimum, value))
if maximum is not None and number > maximum:
raise ValueError("%s must be at most %s, got %r" % (name, maximum, value))
return number
def _measured(spec: dict, value, name: str) -> float:
return _number(
value,
name,
minimum=float(spec.get("min", 0.0)),
maximum=None if "max" not in spec else float(spec["max"]),
)
def _backend() -> str:
try:
import FerroCADGui
except ImportError: return BACKEND
active_provider = getattr(FerroCADGui, "activeProvider", None)
if active_provider is None:
return BACKEND
return active_provider(FEATURE) or BACKEND
class _GizmoSettings:
def schema(self) -> list:
return [dict(entry) for entry in SETTINGS_SCHEMA]
@property
def enabled(self) -> bool:
return bool(_read(_SPECS["enabled"]))
@enabled.setter
def enabled(self, value) -> None:
_write(_SPECS["enabled"], bool(value))
@property
def active_color(self) -> str:
return _colour(_read(_SPECS["active_color"]))
@active_color.setter
def active_color(self, value) -> None:
_write(_SPECS["active_color"], _colour(value))
@property
def inactive_color(self) -> str:
return _colour(_read(_SPECS["inactive_color"]))
@inactive_color.setter
def inactive_color(self, value) -> None:
_write(_SPECS["inactive_color"], _colour(value))
@property
def size(self) -> float:
return _measured(_SPECS["size"], _read(_SPECS["size"]), "the gizmo size")
@size.setter
def size(self, value) -> None:
_write(_SPECS["size"], _measured(_SPECS["size"], value, "the gizmo size"))
@property
def width(self) -> float:
return _measured(_SPECS["width"], _read(_SPECS["width"]), "the gizmo width")
@width.setter
def width(self, value) -> None:
_write(_SPECS["width"], _measured(_SPECS["width"], value, "the gizmo width"))
@property
def opacity(self) -> float:
return _measured(
_SPECS["opacity"],
_read(_SPECS["opacity"]),
"the gizmo opacity",
)
@opacity.setter
def opacity(self, value) -> None:
_write(
_SPECS["opacity"],
_measured(_SPECS["opacity"], value, "the gizmo opacity"),
)
@property
def ghost_alpha(self) -> float:
return _measured(
_SPECS["ghost_alpha"],
_read(_SPECS["ghost_alpha"]),
"the gizmo ghost alpha",
)
@ghost_alpha.setter
def ghost_alpha(self, value) -> None:
_write(
_SPECS["ghost_alpha"],
_measured(_SPECS["ghost_alpha"], value, "the gizmo ghost alpha"),
)
@property
def ring_snap_deg(self) -> float:
return _measured(
_SPECS["ring_snap_deg"],
_read(_SPECS["ring_snap_deg"]),
"the gizmo ring snap",
)
@ring_snap_deg.setter
def ring_snap_deg(self, value) -> None:
_write(
_SPECS["ring_snap_deg"],
_measured(_SPECS["ring_snap_deg"], value, "the gizmo ring snap"),
)
@property
def show_readout(self) -> bool:
return bool(_read(_SPECS["show_readout"]))
@show_readout.setter
def show_readout(self, value) -> None:
_write(_SPECS["show_readout"], bool(value))
def apply(self) -> dict:
return {
"view": {
"gizmo": {
"enabled": self.enabled,
"backend": _backend(),
"active_color": self.active_color,
"inactive_color": self.inactive_color,
"size": self.size,
"width": self.width,
"opacity": self.opacity,
"ghost_alpha": self.ghost_alpha,
"ring_snap_deg": self.ring_snap_deg,
"show_readout": self.show_readout,
}
}
}
def snapshot(self) -> dict:
return {
"enabled": self.enabled,
"active_color": self.active_color,
"inactive_color": self.inactive_color,
"size": self.size,
"width": self.width,
"opacity": self.opacity,
"ghost_alpha": self.ghost_alpha,
"ring_snap_deg": self.ring_snap_deg,
"show_readout": self.show_readout,
}
def reset(self) -> None:
_prefs().Clear()
_INSTANCE = None
def gizmo() -> _GizmoSettings:
global _INSTANCE
if _INSTANCE is None:
_INSTANCE = _GizmoSettings()
return _INSTANCE