flet-map 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

flet_map/polyline_layer.py

@@ -0,0 +1,292 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, List, Optional, Union
+
+from flet.core.control import Control, OptionalNumber
+from flet_map.map import MapLatitudeLongitude
+from flet_map.map_layer import MapLayer
+from flet.core.ref import Ref
+from flet.core.types import ColorEnums, ColorValue, StrokeCap, StrokeJoin
+
+
+class PatternFit(Enum):
+    SCALE_DOWN = "scaleDown"
+    SCALE_UP = "scaleUp"
+    APPEND_DOT = "appendDot"
+    EXTEND_FINAL_DASH = "extendFinalDash"
+
+
+@dataclass
+class StrokePattern:
+    pass
+
+
+@dataclass
+class SolidStrokePattern(StrokePattern):
+    def __post_init__(self):
+        self.type = "solid"
+
+
+@dataclass
+class DashedStrokePattern(StrokePattern):
+    segments: Optional[List[Union[float, int]]] = None
+    pattern_fit: Optional[PatternFit] = PatternFit.SCALE_UP
+
+    def __post_init__(self):
+        self.type = "dashed"
+
+
+@dataclass
+class DottedStrokePattern(StrokePattern):
+    spacing_factor: OptionalNumber = None
+    pattern_fit: Optional[PatternFit] = PatternFit.SCALE_UP
+
+    def __post_init__(self):
+        self.type = "dotted"
+
+
+class PolylineMarker(Control):
+    """
+    A marker for the PolylineLayer.
+
+    -----
+
+    Online docs: https://flet.dev/docs/controls/mappolylinemarker
+    """
+
+    def __init__(
+        self,
+        coordinates: List[MapLatitudeLongitude],
+        colors_stop: Optional[List[Union[float, int]]] = None,
+        gradient_colors: Optional[List[str]] = None,
+        border_color: Optional[ColorValue] = None,
+        color: Optional[ColorValue] = None,
+        stroke_width: OptionalNumber = None,
+        border_stroke_width: OptionalNumber = None,
+        use_stroke_width_in_meter: Optional[bool] = None,
+        stroke_pattern: Optional[StrokePattern] = None,
+        stroke_cap: Optional[StrokeCap] = None,
+        stroke_join: Optional[StrokeJoin] = None,
+        #
+        # Control
+        #
+        ref: Optional[Ref] = None,
+        visible: Optional[bool] = None,
+        data: Any = None,
+    ):
+        Control.__init__(
+            self,
+            ref=ref,
+            visible=visible,
+            data=data,
+        )
+
+        self.coordinates = coordinates
+        self.border_color = border_color
+        self.color = color
+        self.border_stroke_width = border_stroke_width
+        self.stroke_width = stroke_width
+        self.stroke_cap = stroke_cap
+        self.stroke_join = stroke_join
+        self.colors_stop = colors_stop
+        self.gradient_colors = gradient_colors
+        self.use_stroke_width_in_meter = use_stroke_width_in_meter
+        self.stroke_pattern = stroke_pattern
+
+    def _get_control_name(self):
+        return "map_polyline_marker"
+
+    def before_update(self):
+        super().before_update()
+        self._set_attr_json("coordinates", self.__coordinates)
+        if isinstance(self.__colors_stop, list):
+            self._set_attr_json("colorsStop", self.__colors_stop)
+        if isinstance(self.__gradient_colors, list):
+            self._set_attr_json("gradientColors", self.__gradient_colors)
+        self._set_attr_json("strokePattern", self.__stroke_pattern)
+
+    # stroke_cap
+    @property
+    def stroke_cap(self) -> Optional[StrokeCap]:
+        return self.__stroke_cap
+
+    @stroke_cap.setter
+    def stroke_cap(self, value: Optional[StrokeCap]):
+        self.__stroke_cap = value
+        self._set_enum_attr("strokeCap", value, StrokeCap)
+
+    # gradient_colors
+    @property
+    def gradient_colors(self) -> Optional[List[str]]:
+        return self.__gradient_colors
+
+    @gradient_colors.setter
+    def gradient_colors(self, value: Optional[List[str]]):
+        self.__gradient_colors = value
+
+    # stroke_pattern
+    @property
+    def stroke_pattern(self) -> Optional[StrokePattern]:
+        return self.__stroke_pattern
+
+    @stroke_pattern.setter
+    def stroke_pattern(self, value: Optional[StrokePattern]):
+        self.__stroke_pattern = value
+
+    # colors_stop
+    @property
+    def colors_stop(self) -> Optional[List[Union[float, int]]]:
+        return self.__colors_stop
+
+    @colors_stop.setter
+    def colors_stop(self, value: Optional[List[Union[float, int]]]):
+        self.__colors_stop = value
+
+    # stroke_join
+    @property
+    def stroke_join(self) -> Optional[StrokeJoin]:
+        return self.__stroke_join
+
+    @stroke_join.setter
+    def stroke_join(self, value: Optional[StrokeJoin]):
+        self.__stroke_join = value
+        self._set_enum_attr("strokeJoin", value, StrokeJoin)
+
+    # use_stroke_width_in_meter
+    @property
+    def use_stroke_width_in_meter(self) -> bool:
+        return self._get_attr(
+            "useStrokeWidthInMeter", data_type="bool", def_value=False
+        )
+
+    @use_stroke_width_in_meter.setter
+    def use_stroke_width_in_meter(self, value: Optional[bool]):
+        self._set_attr("useStrokeWidthInMeter", value)
+
+    # color
+    @property
+    def color(self) -> Optional[ColorValue]:
+        return self.__color
+
+    @color.setter
+    def color(self, value: Optional[ColorValue]):
+        self.__color = value
+        self._set_enum_attr("color", value, ColorEnums)
+
+    # border_color
+    @property
+    def border_color(self) -> Optional[ColorValue]:
+        return self.__border_color
+
+    @border_color.setter
+    def border_color(self, value: Optional[ColorValue]):
+        self.__border_color = value
+        self._set_enum_attr("borderColor", value, ColorEnums)
+
+    # border_stroke_width
+    @property
+    def border_stroke_width(self) -> float:
+        return self._get_attr("borderStrokeWidth", data_type="float", def_value=0.0)
+
+    @border_stroke_width.setter
+    def border_stroke_width(self, value: OptionalNumber):
+        assert value is None or value >= 0, "border_stroke_width cannot be negative"
+        self._set_attr("borderStrokeWidth", value)
+
+    # stroke_width
+    @property
+    def stroke_width(self) -> float:
+        return self._get_attr("strokeWidth", data_type="float", def_value=1.0)
+
+    @stroke_width.setter
+    def stroke_width(self, value: OptionalNumber):
+        assert value is None or value >= 0, "stroke_width cannot be negative"
+        self._set_attr("strokeWidth", value)
+
+    # coordinates
+    @property
+    def coordinates(self) -> List[MapLatitudeLongitude]:
+        return self.__coordinates
+
+    @coordinates.setter
+    def coordinates(self, value: List[MapLatitudeLongitude]):
+        self.__coordinates = value
+
+
+class PolylineLayer(MapLayer):
+    """
+    A layer to display PolylineMarkers.
+
+    -----
+
+    Online docs: https://flet.dev/docs/controls/mappolylinelayer
+    """
+
+    def __init__(
+        self,
+        polylines: List[PolylineMarker],
+        culling_margin: OptionalNumber = None,
+        min_hittable_radius: OptionalNumber = None,
+        simplify_tolerance: OptionalNumber = None,
+        #
+        # MapLayer
+        #
+        ref: Optional[Ref] = None,
+        visible: Optional[bool] = None,
+        data: Any = None,
+    ):
+        MapLayer.__init__(
+            self,
+            ref=ref,
+            visible=visible,
+            data=data,
+        )
+
+        self.polylines = polylines
+        self.culling_margin = culling_margin
+        self.min_hittable_radius = min_hittable_radius
+        self.simplify_tolerance = simplify_tolerance
+
+    def _get_control_name(self):
+        return "map_polyline_layer"
+
+    def _get_children(self):
+        return self.__polylines
+
+    # polylines
+    @property
+    def polylines(self) -> List[PolylineMarker]:
+        return self.__polylines
+
+    @polylines.setter
+    def polylines(self, value: List[PolylineMarker]):
+        self.__polylines = value
+
+    # culling_margin
+    @property
+    def culling_margin(self) -> float:
+        return self._get_attr("cullingMargin", data_type="float", def_value=10.0)
+
+    @culling_margin.setter
+    def culling_margin(self, value: OptionalNumber):
+        self._set_attr("cullingMargin", value)
+
+    # simplification_tolerance
+    @property
+    def simplification_tolerance(self) -> float:
+        return self._get_attr(
+            "simplificationTolerance", data_type="float", def_value=0.4
+        )
+
+    @simplification_tolerance.setter
+    def simplification_tolerance(self, value: OptionalNumber):
+        self._set_attr("simplificationTolerance", value)
+
+    # min_hittable_radius
+    @property
+    def min_hittable_radius(self) -> float:
+        return self._get_attr("minHittableRadius", data_type="float", def_value=10.0)
+
+    @min_hittable_radius.setter
+    def min_hittable_radius(self, value: OptionalNumber):
+        self._set_attr("minHittableRadius", value)

flet_map/rich_attribution.py

@@ -0,0 +1,141 @@
+from enum import Enum
+from typing import Any, List, Optional
+
+from flet.core.border_radius import BorderRadius
+from flet.core.control import OptionalNumber
+from flet_map.map_layer import MapLayer
+from flet_map.text_source_attribution import TextSourceAttribution
+from flet.core.ref import Ref
+from flet.core.types import ColorEnums, ColorValue
+
+
+class AttributionAlignment(Enum):
+    BOTTOM_LEFT = "bottomLeft"
+    BOTTOM_RIGHT = "bottomRight"
+
+
+class RichAttribution(MapLayer):
+    """
+    An animated and interactive attribution layer that supports both logos/images and text
+    (displayed in a popup controlled by an icon button adjacent to the logos).
+
+    -----
+
+    Online docs: https://flet.dev/docs/controls/maprichattribution
+    """
+
+    def __init__(
+        self,
+        attributions: List[TextSourceAttribution],
+        alignment: Optional[AttributionAlignment] = None,
+        popup_bgcolor: Optional[ColorValue] = None,
+        popup_border_radius: Optional[BorderRadius] = None,
+        popup_initial_display_duration: Optional[int] = None,
+        permanent_height: OptionalNumber = None,
+        show_flutter_map_attribution: Optional[bool] = None,
+        #
+        # MapLayer
+        #
+        ref: Optional[Ref] = None,
+        visible: Optional[bool] = None,
+        data: Any = None,
+    ):
+
+        MapLayer.__init__(
+            self,
+            ref=ref,
+            visible=visible,
+            data=data,
+        )
+
+        self.attributions = attributions
+        self.alignment = alignment
+        self.popup_bgcolor = popup_bgcolor
+        self.permanent_height = permanent_height
+        self.show_flutter_map_attribution = show_flutter_map_attribution
+        self.popup_border_radius = popup_border_radius
+        self.popup_initial_display_duration = popup_initial_display_duration
+
+    def _get_control_name(self):
+        return "map_rich_attribution"
+
+    def _get_children(self):
+        return self.attributions
+
+    def before_update(self):
+        super().before_update()
+        self._set_attr_json("popupBorderRadius", self.__popup_border_radius)
+        self._set_attr_json("alignment", self.__alignment)
+
+    # permanent_height
+    @property
+    def permanent_height(self) -> float:
+        return self._get_attr("permanentHeight", data_type="float", def_value=24.0)
+
+    @permanent_height.setter
+    def permanent_height(self, value: OptionalNumber):
+        assert value is None or value >= 0, "permanent_height cannot be negative"
+        self._set_attr("permanentHeight", value)
+
+    # popup_initial_display_duration
+    @property
+    def popup_initial_display_duration(self) -> int:
+        return self._get_attr(
+            "popupInitialDisplayDuration", data_type="int", def_value=0
+        )
+
+    @popup_initial_display_duration.setter
+    def popup_initial_display_duration(self, value: Optional[int]):
+        assert (
+            value is None or value >= 0
+        ), "popup_initial_display_duration cannot be negative"
+        self._set_attr("popupInitialDisplayDuration", value)
+
+    # popup_border_radius
+    @property
+    def popup_border_radius(self) -> Optional[BorderRadius]:
+        return self.__popup_border_radius
+
+    @popup_border_radius.setter
+    def popup_border_radius(self, value: Optional[BorderRadius]):
+        self.__popup_border_radius = value
+
+    # alignment
+    @property
+    def alignment(self) -> Optional[AttributionAlignment]:
+        return self.__alignment
+
+    @alignment.setter
+    def alignment(self, value: Optional[AttributionAlignment]):
+        self.__alignment = value
+        self._set_enum_attr("alignment", value, AttributionAlignment)
+
+    # show_flutter_map_attribution
+    @property
+    def show_flutter_map_attribution(self) -> bool:
+        return self._get_attr(
+            "showFlutterMapAttribution", data_type="bool", def_value=True
+        )
+
+    @show_flutter_map_attribution.setter
+    def show_flutter_map_attribution(self, value: Optional[bool]):
+        self._set_attr("showFlutterMapAttribution", value)
+
+    # popup_bgcolor
+    @property
+    def popup_bgcolor(self) -> Optional[str]:
+        return self.__popup_bgcolor
+
+    @popup_bgcolor.setter
+    def popup_bgcolor(self, value: Optional[str]):
+        self.__popup_bgcolor = value
+        self._set_enum_attr("popupBgcolor", value, ColorEnums)
+
+    # attributions
+    @property
+    def attributions(self) -> List[TextSourceAttribution]:
+        return self.__attributions
+
+    @attributions.setter
+    def attributions(self, value: List[TextSourceAttribution]):
+        self.__attributions = value

flet_map/simple_attribution.py

@@ -0,0 +1,86 @@
+from typing import Any, Optional
+
+from flet.core.alignment import Alignment
+from flet_map.map_layer import MapLayer
+from flet.core.ref import Ref
+from flet.core.types import ColorEnums, ColorValue, OptionalControlEventCallable
+
+
+class SimpleAttribution(MapLayer):
+    """
+    A simple attribution layer displayed on the Map.
+
+    -----
+
+    Online docs: https://flet.dev/docs/controls/mapsimpleattribution
+    """
+
+    def __init__(
+        self,
+        text: str,
+        alignment: Optional[Alignment] = None,
+        bgcolor: Optional[ColorValue] = None,
+        on_click: OptionalControlEventCallable = None,
+        #
+        # MapLayer
+        #
+        ref: Optional[Ref] = None,
+        visible: Optional[bool] = None,
+        data: Any = None,
+    ):
+
+        MapLayer.__init__(
+            self,
+            ref=ref,
+            visible=visible,
+            data=data,
+        )
+
+        self.text = text
+        self.alignment = alignment
+        self.bgcolor = bgcolor
+        self.on_click = on_click
+
+    def _get_control_name(self):
+        return "map_simple_attribution"
+
+    def before_update(self):
+        super().before_update()
+        self._set_attr_json("alignment", self.__alignment)
+
+    # alignment
+    @property
+    def alignment(self) -> Optional[Alignment]:
+        return self.__alignment
+
+    @alignment.setter
+    def alignment(self, value: Optional[Alignment]):
+        self.__alignment = value
+
+    # bgcolor
+    @property
+    def bgcolor(self) -> Optional[ColorValue]:
+        return self.__bgcolor
+
+    @bgcolor.setter
+    def bgcolor(self, value: Optional[ColorValue]):
+        self.__bgcolor = value
+        self._set_enum_attr("bgcolor", value, ColorEnums)
+
+    # text
+    @property
+    def text(self) -> str:
+        return self._get_attr("text")
+
+    @text.setter
+    def text(self, value: str):
+        self._set_attr("text", value)
+
+    # on_click
+    @property
+    def on_change(self) -> OptionalControlEventCallable:
+        return self._get_event_handler("click")
+
+    @on_change.setter
+    def on_change(self, handler: OptionalControlEventCallable):
+        self._add_event_handler("click", handler)

flet_map/text_source_attribution.py

@@ -0,0 +1,87 @@
+from typing import Any, Optional
+
+from flet.core.control import Control
+from flet.core.ref import Ref
+from flet.core.text_style import TextStyle
+from flet.core.types import OptionalControlEventCallable
+
+
+class TextSourceAttribution(Control):
+    """
+    A text source attribution displayed on the Map.
+    For it to be displayed, it should be part of a RichAttribution.attributions list.
+
+    -----
+
+    Online docs: https://flet.dev/docs/controls/maptextsourceattribution
+    """
+
+    def __init__(
+        self,
+        text: str,
+        text_style: Optional[TextStyle] = None,
+        prepend_copyright: Optional[bool] = None,
+        on_click: OptionalControlEventCallable = None,
+        #
+        # Control
+        #
+        ref: Optional[Ref] = None,
+        visible: Optional[bool] = None,
+        data: Any = None,
+    ):
+
+        Control.__init__(
+            self,
+            ref=ref,
+            visible=visible,
+            data=data,
+        )
+
+        self.text = text
+        self.text_style = text_style
+        self.prepend_copyright = prepend_copyright
+        self.on_click = on_click
+
+    def _get_control_name(self):
+        return "map_text_source_attribution"
+
+    def before_update(self):
+        super().before_update()
+        if isinstance(self.__text_style, TextStyle):
+            self._set_attr_json("textStyle", self.__text_style)
+
+    # text_style
+    @property
+    def text_style(self) -> Optional[TextStyle]:
+        return self.__text_style
+
+    @text_style.setter
+    def text_style(self, value: Optional[TextStyle]):
+        self.__text_style = value
+
+    # prepend_copyright
+    @property
+    def prepend_copyright(self) -> bool:
+        return self._get_attr("prependCopyright", data_type="bool", def_value=True)
+
+    @prepend_copyright.setter
+    def prepend_copyright(self, value: Optional[bool]):
+        self._set_attr("prependCopyright", value)
+
+    # text
+    @property
+    def text(self) -> str:
+        return self._get_attr("text")
+
+    @text.setter
+    def text(self, value: str):
+        self._set_attr("text", value)
+
+    # on_click
+    @property
+    def on_click(self) -> OptionalControlEventCallable:
+        return self._get_event_handler("click")
+
+    @on_click.setter
+    def on_click(self, handler: OptionalControlEventCallable):
+        self._add_event_handler("click", handler)