Guideline related George functions¶

def tv_guideline_enum(position: int, guideline_type: GuidelineType) -> int:
    """Check the existence of a guideline at the given position.

    Raises:
        GeorgeError: if given an invalid scene id or clip position or elements have been removed
    """
    return int(
        send_cmd(
            "tv_GuidelineEnum",
            position,
            guideline_type.value,
            error_values=[-1, -2, GrgErrorValue.NONE],
        )
    )

def tv_guideline_remove_all(guideline_type: GuidelineType) -> None:
    """Removes all guidelines of the given type."""
    send_cmd(
        "tv_GuidelineRemove",
        "all",
        guideline_type.value,
        error_values=[-1, -2],
    )

def tv_guideline_remove(position: int, guideline_type: GuidelineType) -> None:
    """Removes the guidelines at the given position and type."""
    send_cmd(
        "tv_GuidelineRemove",
        guideline_type.value,
        position,
        error_values=[GrgErrorValue.NONE],
    )

def tv_guideline_name_get(position: int) -> str:
    """Get the name of the guideline at the given position."""
    return str(
        send_cmd(
            "tv_GuidelineName",
            position,
            error_values=[GrgErrorValue.ERROR],
        )
    ).strip()

def tv_guideline_name_set(position: int, name: str) -> None:
    """Set the name of the guideline at the given position."""
    send_cmd(
        "tv_GuidelineName",
        position,
        name,
        error_values=[GrgErrorValue.ERROR],
    )

def tv_guideline_visibility_get(position: int, on_global: bool = False) -> bool:
    """Get the visibility of the guideline at the given position."""
    return bool(
        int(
            send_cmd(
                "tv_GuidelineVisible",
                position if not on_global else "global",
                error_values=[-1, -2],
            )
        )
    )

def tv_guideline_visibility_set(position: int, is_visible: bool, on_global: bool = False) -> None:
    """Set the visibility of the guideline at the given position."""
    send_cmd(
        "tv_GuidelineVisible",
        position if not on_global else "global",
        int(is_visible),
        error_values=[-1, -2],
    )

def tv_guideline_visibility_set_all(
    guideline_type: GuidelineType | None, is_visible: bool, apply_all: bool = False
) -> None:
    """Set the visibility of the guideline of the given type or all of them regardless of type.

    Args:
        guideline_type: the guideline type or None if `apply_all` is used.
        is_visible: True to set as visible, False otherwise.
        apply_all: True to apply to all guidelines regardless of type.
    """
    apply_to = "all" if apply_all or guideline_type is None else guideline_type.value

    send_cmd(
        "tv_GuidelineVisible",
        apply_to,
        int(is_visible),
        error_values=[-1, -2],
    )

def tv_guideline_margin_get(position: int, on_global: bool = False) -> int:
    """Get the margin of the guideline at the given position."""
    return int(
        send_cmd(
            "tv_GuidelineMarge",
            position if not on_global else "global",
            error_values=[-1, -2],
        )
    )

def tv_guideline_margin_set(position: int, margin: int) -> None:
    """Set the margin of the guideline at the given position."""
    send_cmd(
        "tv_GuidelineMarge",
        position,
        margin,
        error_values=[-1, -2],
    )

def tv_guideline_margin_set_all(guideline_type: GuidelineType | None, margin: int, apply_all: bool = False) -> None:
    """Set the margin of the guideline of the given type or all of them regardless of type.

    Args:
        guideline_type: the guideline type or None if `apply_all` is used.
        margin: the margin to apply.
        apply_all: True to apply to all guidelines regardless of type.
    """
    apply_to = "all" if apply_all or guideline_type is None else guideline_type.value

    send_cmd(
        "tv_GuidelineMarge",
        apply_to,
        margin,
        error_values=[-1, -2],
    )

def tv_guideline_color_get(position: int, on_global: bool = False) -> RGBAColor:
    """Get the color of the guideline at the given position."""
    result = send_cmd(
        "tv_GuidelineColor",
        position if not on_global else "global",
        error_values=[-1, -2],
    )
    r, g, b, a = result.split()
    return RGBAColor(*[int(c) for c in (r, g, b, a)])

def tv_guideline_color_set(position: int, color: RGBAColor) -> None:
    """Set the color of the guideline at the given position."""
    send_cmd(
        "tv_GuidelineColor",
        position,
        color.r,
        color.g,
        color.b,
        color.a,
        error_values=[-1, -2],
    )

def tv_guideline_color_set_all(guideline_type: GuidelineType | None, color: RGBAColor, apply_all: bool = False) -> None:
    """Set the color of the guideline of the given type or all of them regardless of type.

    Args:
        guideline_type: the guideline type or None if `apply_all` is used.
        color: the color to apply.
        apply_all: True to apply to all guidelines regardless of type.
    """
    apply_to = "all" if apply_all or guideline_type is None else guideline_type.value

    send_cmd(
        "tv_GuidelineColor",
        apply_to,
        color.r,
        color.g,
        color.b,
        color.a,
        error_values=[-1, -2],
    )

def tv_guideline_snap_get(position: int, on_global: bool = False) -> bool:
    """Get the snap status of the guideline at the given position."""
    return bool(
        int(
            send_cmd(
                "tv_GuidelineSnap",
                position if not on_global else "global",
                error_values=[-1, -2],
            )
        )
    )

def tv_guideline_snap_set(position: int, snap: bool, on_global: bool = False) -> None:
    """Set the guideline snap at the given position."""
    send_cmd(
        "tv_GuidelineSnap",
        position if not on_global else "global",
        int(snap),
        error_values=[-1, -2],
    )

def tv_guideline_snap_set_all(guideline_type: GuidelineType | None, snap: bool, apply_all: bool = False) -> None:
    """Set the guideline snap for the given type or all of them regardless of type.

    Args:
        guideline_type: the guideline type or None if `apply_all` is used.
        snap: True to snap, False otherwise.
        apply_all: True to apply to all guidelines regardless of type.
    """
    apply_to = "all" if apply_all or guideline_type is None else guideline_type.value

    send_cmd(
        "tv_GuidelineSnap",
        apply_to,
        int(snap),
        error_values=[-1, -2],
    )

def tv_guideline_collapse_get(position: int) -> bool:
    """Get the collapse status of the guideline at the given position."""
    return bool(
        int(
            send_cmd(
                "tv_guidelineCollapse",
                position,
                error_values=[-1, -2],
            )
        )
    )

def tv_guideline_collapse_set(position: int, collapse: bool) -> None:
    """Set the guideline collapse at the given position."""
    send_cmd(
        "tv_guidelineCollapse",
        position,
        int(collapse),
        error_values=[-1, -2],
    )

def tv_guideline_add_image(
    img_path: Path | str | None = None,
    x: float | None = None,
    y: float | None = None,
    rotation: float | None = None,
    scale: float | None = None,
    flip: FlipDirection | None = None,
    alpha_mode: GuidelineAlphaMode | None = None,
) -> int:
    """Set info for the image guideline at the given position."""
    args = args_dict_to_list(
        {
            "path": img_path,
            "x": x,
            "y": y,
            "rotation": rotation,
            "scale": scale,
            "flip": flip.value if flip is not None else None,
            "alphamode": alpha_mode.value if alpha_mode is not None else None,
        }
    )

    return int(
        send_cmd(
            "tv_GuidelineAdd",
            "image",
            *args,
            error_values=[-1, -2],
        )
    )

def tv_guideline_modify_image_get(position: int) -> TVPGuidelineImage:
    """Get info for the image guideline at the given position."""
    result = send_cmd(
        "tv_GuidelineModify",
        position,
        error_values=[-1, -2],
    )

    guideline: dict[str, Any] = tv_parse_dict(result, with_fields=TVPGuidelineImage)
    guideline["position"] = position
    return TVPGuidelineImage(**guideline)

def tv_guideline_modify_image_set(
    position: int,
    img_path: Path | str | None = None,
    x: float | None = None,
    y: float | None = None,
    rotation: float | None = None,
    scale: float | None = None,
    flip: FlipDirection | None = None,
) -> None:
    """Set info for the image guideline at the given position."""
    args = args_dict_to_list(
        {
            "path": Path(img_path).as_posix() if img_path is not None else None,
            "x": x,
            "y": y,
            "rotation": rotation,
            "scale": scale,
            "flip": flip.value if flip is not None else None,
        }
    )

    send_cmd(
        "tv_GuidelineModify",
        position,
        *args,
        error_values=[-1, -2],
    )

def tv_guideline_add_line(
    x: float | None = None,
    y: float | None = None,
    angle: float | None = None,
) -> int:
    """Set info for the image guideline at the given position."""
    args = args_dict_to_list(
        {
            "x": x,
            "y": y,
            "angle": angle,
        }
    )

    return int(
        send_cmd(
            "tv_GuidelineAdd",
            "line",
            *args,
            error_values=[-1, -2],
        )
    )

def tv_guideline_modify_line_get(position: int) -> TVPGuidelineLine:
    """Get info for the line guideline at the given position."""
    result = send_cmd(
        "tv_GuidelineModify",
        position,
        error_values=[-1, -2],
    )

    guideline: dict[str, Any] = tv_parse_dict(result, with_fields=TVPGuidelineLine)
    guideline["position"] = position
    return TVPGuidelineLine(**guideline)

def tv_guideline_modify_line_set(
    position: int,
    x: float | None = None,
    y: float | None = None,
    angle: float | None = None,
) -> None:
    """Set info for the line guideline at the given position."""
    args = args_dict_to_list(
        {
            "x": x,
            "y": y,
            "angle": angle,
        }
    )

    send_cmd(
        "tv_GuidelineModify",
        position,
        *args,
        error_values=[-1, -2],
    )

def tv_guideline_add_segment(
    x1: float | None = None,
    y1: float | None = None,
    x2: float | None = None,
    y2: float | None = None,
) -> int:
    """Set info for the image guideline at the given position."""
    args = args_dict_to_list(
        {
            "x1": x1,
            "y1": y1,
            "x2": x2,
            "y2": y2,
        }
    )

    return int(
        send_cmd(
            "tv_GuidelineAdd",
            "segment",
            *args,
            error_values=[-1, -2],
        )
    )

def tv_guideline_modify_segment_get(position: int) -> TVPGuidelineSegment:
    """Get info for the segment guideline at the given position."""
    result = send_cmd(
        "tv_GuidelineModify",
        position,
        error_values=[-1, -2],
    )

    guideline: dict[str, Any] = tv_parse_dict(result, with_fields=TVPGuidelineSegment)
    guideline["position"] = position
    return TVPGuidelineSegment(**guideline)

def tv_guideline_modify_segment_set(
    position: int,
    x1: float | None = None,
    y1: float | None = None,
    x2: float | None = None,
    y2: float | None = None,
) -> None:
    """Set info for the segment guideline at the given position."""
    args = args_dict_to_list(
        {
            "x1": x1,
            "y1": y1,
            "x2": x2,
            "y2": y2,
        }
    )

    send_cmd(
        "tv_GuidelineModify",
        position,
        *args,
        error_values=[-1, -2],
    )

def tv_guideline_add_circle(
    x: float | None = None,
    y: float | None = None,
    radius: float | None = None,
) -> int:
    """Set info for the image guideline at the given position."""
    args = args_dict_to_list(
        {
            "x": x,
            "y": y,
            "radius": radius,
        }
    )

    return int(
        send_cmd(
            "tv_GuidelineAdd",
            "circle",
            *args,
            error_values=[-1, -2],
        )
    )

def tv_guideline_modify_circle_get(position: int) -> TVPGuidelineCircle:
    """Get info for the circle guideline at the given position."""
    result = send_cmd(
        "tv_GuidelineModify",
        position,
        error_values=[-1, -2],
    )

    guideline: dict[str, Any] = tv_parse_dict(result, with_fields=TVPGuidelineCircle)
    guideline["position"] = position
    return TVPGuidelineCircle(**guideline)

def tv_guideline_modify_circle_set(
    position: int,
    x: float | None = None,
    y: float | None = None,
    radius: float | None = None,
) -> None:
    """Set info for the circle guideline at the given position."""
    args = args_dict_to_list(
        {
            "x": x,
            "y": y,
            "radius": radius,
        }
    )

    send_cmd(
        "tv_GuidelineModify",
        position,
        *args,
        error_values=[-1, -2],
    )

def tv_guideline_add_ellipse(
    x: float | None = None,
    y: float | None = None,
    radius_a: float | None = None,
    radius_b: float | None = None,
) -> int:
    """Set info for the image guideline at the given position."""
    args = args_dict_to_list(
        {
            "x": x,
            "y": y,
            "radiusa": radius_a,
            "radiusb": radius_b,
        }
    )

    return int(
        send_cmd(
            "tv_GuidelineAdd",
            "ellipse",
            *args,
            error_values=[-1, -2],
        )
    )

def tv_guideline_modify_ellipse_get(position: int) -> TVPGuidelineEllipse:
    """Get info for the ellipse guideline at the given position."""
    result = send_cmd(
        "tv_GuidelineModify",
        position,
        error_values=[-1, -2],
    )

    guideline: dict[str, Any] = tv_parse_dict(result, with_fields=TVPGuidelineEllipse)
    guideline["position"] = position
    return TVPGuidelineEllipse(**guideline)

def tv_guideline_modify_ellipse_set(
    position: int,
    x: float | None = None,
    y: float | None = None,
    radius_a: float | None = None,
    radius_b: float | None = None,
) -> None:
    """Set info for the ellipse guideline at the given position."""
    args = args_dict_to_list(
        {
            "x": x,
            "y": y,
            "radiusa": radius_a,
            "radiusb": radius_b,
        }
    )

    send_cmd(
        "tv_GuidelineModify",
        position,
        *args,
        error_values=[-1, -2],
    )

def tv_guideline_add_grid(
    x: float | None = None,
    y: float | None = None,
    width: float | None = None,
    height: float | None = None,
) -> int:
    """Set info for the image guideline at the given position."""
    args = args_dict_to_list(
        {
            "x": x,
            "y": y,
            "w": width,
            "h": height,
        }
    )

    return int(
        send_cmd(
            "tv_GuidelineAdd",
            "grid",
            *args,
            error_values=[-1, -2],
        )
    )

def tv_guideline_modify_grid_get(position: int) -> TVPGuidelineGrid:
    """Get info for the grid guideline at the given position."""
    result = send_cmd(
        "tv_GuidelineModify",
        position,
        error_values=[-1, -2],
    )

    guideline: dict[str, Any] = tv_parse_dict(result, with_fields=TVPGuidelineGrid)
    guideline["position"] = position
    return TVPGuidelineGrid(**guideline)

def tv_guideline_modify_grid_set(
    position: int,
    x: float | None = None,
    y: float | None = None,
    width: float | None = None,
    height: float | None = None,
) -> None:
    """Set info for the grid guideline at the given position."""
    args = args_dict_to_list(
        {
            "x": x,
            "y": y,
            "w": width,
            "h": height,
        }
    )

    send_cmd(
        "tv_GuidelineModify",
        position,
        *args,
        error_values=[-1, -2],
    )

def tv_guideline_add_marks(
    count_x: int | None = None,
    count_y: int | None = None,
) -> int:
    """Set info for the image guideline at the given position."""
    args = args_dict_to_list(
        {
            "countx": count_x,
            "county": count_y,
        }
    )

    return int(
        send_cmd(
            "tv_GuidelineAdd",
            "marks",
            *args,
            error_values=[-1, -2],
        )
    )

def tv_guideline_modify_marks_get(position: int) -> TVPGuidelineMarks:
    """Get info for the marks guideline at the given position."""
    result = send_cmd(
        "tv_GuidelineModify",
        position,
        error_values=[-1, -2],
    )

    guideline: dict[str, Any] = tv_parse_dict(result, with_fields=TVPGuidelineMarks)
    guideline["position"] = position
    return TVPGuidelineMarks(**guideline)

def tv_guideline_modify_marks_set(
    position: int,
    count_x: int | None = None,
    count_y: int | None = None,
) -> None:
    """Set info for the marks guideline at the given position.

    Warning:
        function `tv_GuidelineModify` doesn't seem to work in tvpaint, values are never changed.

    """
    log.warning("function `tv_GuidelineModify` doesn't seem to work in tvpaint, values are never changed.")
    args = args_dict_to_list(
        {
            "countx": count_x,
            "county": count_y,
        }
    )

    send_cmd(
        "tv_GuidelineModify",
        position,
        *args,
        error_values=[-1, -2],
    )

def tv_guideline_add_safe_area(
    sf_out: int | None = None,
    sf_in: int | None = None,
) -> int:
    """Set info for the image guideline at the given position."""
    args = args_dict_to_list(
        {
            "out": sf_out,
            "in": sf_in,
        }
    )

    return int(
        send_cmd(
            "tv_GuidelineAdd",
            "safearea",
            *args,
            error_values=[-1, -2],
        )
    )

def tv_guideline_modify_safe_area_get(position: int) -> TVPGuidelineSafeArea:
    """Get info for the safe area guideline at the given position."""
    result = send_cmd(
        "tv_GuidelineModify",
        position,
        error_values=[-1, -2],
    )

    guideline: dict[str, Any] = tv_parse_dict(result, with_fields=TVPGuidelineSafeArea)
    guideline["position"] = position
    return TVPGuidelineSafeArea(**guideline)

def tv_guideline_modify_safe_area_set(
    position: int,
    sf_out: float | None = None,
    sf_in: float | None = None,
) -> None:
    """Set info for the safe area guideline at the given position."""
    args = args_dict_to_list(
        {
            "out": sf_out,
            "in": sf_in,
        }
    )

    send_cmd(
        "tv_GuidelineModify",
        position,
        *args,
        error_values=[-1, -2],
    )

def tv_guideline_add_vanish_point_1(
    x: float | None = None,
    y: float | None = None,
    grid: bool | None = None,
) -> int:
    """Set info for the image guideline at the given position."""
    args = args_dict_to_list(
        {
            "x": x,
            "y": y,
            "grid": int(grid) if grid is not None else None,
        }
    )

    return int(
        send_cmd(
            "tv_GuidelineAdd",
            "vanishpoint1",
            *args,
            error_values=[-1, -2],
        )
    )

def tv_guideline_modify_vanish_point_1_get(position: int) -> TVPGuidelineVanishPoint1:
    """Get info for the vanish point 1 guideline at the given position."""
    result = send_cmd(
        "tv_GuidelineModify",
        position,
        error_values=[-1, -2],
    )

    guideline: dict[str, Any] = tv_parse_dict(result, with_fields=TVPGuidelineVanishPoint1)
    guideline["position"] = position
    return TVPGuidelineVanishPoint1(**guideline)

def tv_guideline_modify_vanish_point_1_set(
    position: int,
    x: float | None = None,
    y: float | None = None,
    ray: int | None = None,
    grid: bool | None = None,
) -> None:
    """Set info for the vanish point 1 guideline at the given position."""
    args = args_dict_to_list(
        {
            "x": x,
            "y": y,
            "ray": ray,
            "grid": int(grid) if grid is not None else None,
        }
    )

    send_cmd(
        "tv_GuidelineModify",
        position,
        *args,
        error_values=[-1, -2],
    )

def tv_guideline_add_vanish_point_2(
    x1: float | None = None,
    y1: float | None = None,
    x2: float | None = None,
    y2: float | None = None,
) -> int:
    """Set info for the image guideline at the given position."""
    args = args_dict_to_list(
        {
            "x1": x1,
            "y1": y1,
            "x2": x2,
            "y2": y2,
        }
    )

    return int(
        send_cmd(
            "tv_GuidelineAdd",
            "vanishpoint2",
            *args,
            error_values=[-1, -2],
        )
    )

def tv_guideline_modify_vanish_point_2_get(position: int) -> TVPGuidelineVanishPoint2:
    """Get info for the vanish point 2 guideline at the given position."""
    result = send_cmd(
        "tv_GuidelineModify",
        position,
        error_values=[-1, -2],
    )

    guideline: dict[str, Any] = tv_parse_dict(result, with_fields=TVPGuidelineVanishPoint2)
    guideline["position"] = position
    return TVPGuidelineVanishPoint2(**guideline)

def tv_guideline_modify_vanish_point_2_set(
    position: int,
    x1: float | None = None,
    y1: float | None = None,
    x2: float | None = None,
    y2: float | None = None,
    ray: int | None = None,
) -> None:
    """Set info for the vanish point 2 guideline at the given position."""
    args = args_dict_to_list(
        {
            "x1": x1,
            "y1": y1,
            "x2": x2,
            "y2": y2,
            "ray": ray,
        }
    )

    send_cmd(
        "tv_GuidelineModify",
        position,
        *args,
        error_values=[-1, -2],
    )