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

flet_map/marker_layer.py

@@ -0,0 +1,183 @@
+from typing import Any, List, Optional
+
+from flet.core.alignment import Alignment
+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
+
+
+class Marker(Control):
+    """
+    A marker displayed on the Map at the specified location through the MarkerLayer.
+
+    -----
+
+    Online docs: https://flet.dev/docs/controls/mapmarker
+    """
+
+    def __init__(
+        self,
+        content: Control,
+        coordinates: MapLatitudeLongitude,
+        rotate: Optional[bool] = None,
+        height: OptionalNumber = None,
+        width: OptionalNumber = None,
+        alignment: Optional[Alignment] = None,
+        #
+        # Control
+        #
+        ref: Optional[Ref] = None,
+        visible: Optional[bool] = None,
+        data: Any = None,
+    ):
+        Control.__init__(
+            self,
+            ref=ref,
+            visible=visible,
+            data=data,
+        )
+
+        self.content = content
+        self.coordinates = coordinates
+        self.rotate = rotate
+        self.height = height
+        self.width = width
+        self.alignment = alignment
+
+    def _get_control_name(self):
+        return "map_marker"
+
+    def _get_children(self):
+        return [self.__content]
+
+    def before_update(self):
+        super().before_update()
+        self._set_attr_json("alignment", self.__alignment)
+        self._set_attr_json("coordinates", self.__coordinates)
+
+    # content
+    @property
+    def content(self) -> Optional[Alignment]:
+        return self.__content
+
+    @content.setter
+    def content(self, value: Optional[Alignment]):
+        self.__content = value
+
+    # rotate
+    @property
+    def rotate(self) -> bool:
+        return self._get_attr("rotate", data_type="bool", def_value=False)
+
+    @rotate.setter
+    def rotate(self, value: Optional[bool]):
+        self._set_attr("rotate", value)
+
+    # height
+    @property
+    def height(self) -> float:
+        return self._get_attr("height", data_type="float", def_value=30.0)
+
+    @height.setter
+    def height(self, value: OptionalNumber):
+        assert value is None or value >= 0, "height cannot be negative"
+        self._set_attr("height", value)
+
+    # width
+    @property
+    def width(self) -> float:
+        return self._get_attr("width", data_type="float", def_value=30.0)
+
+    @width.setter
+    def width(self, value: OptionalNumber):
+        assert value is None or value >= 0, "width cannot be negative"
+        self._set_attr("width", value)
+
+    # alignment
+    @property
+    def alignment(self) -> Optional[Alignment]:
+        return self.__alignment
+
+    @alignment.setter
+    def alignment(self, value: Optional[Alignment]):
+        self.__alignment = value
+
+    # coordinates
+    @property
+    def coordinates(self) -> MapLatitudeLongitude:
+        return self.__coordinates
+
+    @coordinates.setter
+    def coordinates(self, value: MapLatitudeLongitude):
+        self.__coordinates = value
+
+
+class MarkerLayer(MapLayer):
+    """
+    A layer to display Markers.
+
+    -----
+
+    Online docs: https://flet.dev/docs/controls/mapmarkerlayer
+    """
+
+    def __init__(
+        self,
+        markers: List[Marker],
+        alignment: Optional[Alignment] = None,
+        rotate: 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.markers = markers
+        self.alignment = alignment
+        self.rotate = rotate
+
+    def _get_control_name(self):
+        return "map_marker_layer"
+
+    def _get_children(self):
+        return self.__markers
+
+    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
+
+    # markers
+    @property
+    def markers(self) -> List[Marker]:
+        return self.__markers
+
+    @markers.setter
+    def markers(self, value: List[Marker]):
+        self.__markers = value
+
+    # rotate
+    @property
+    def rotate(self) -> bool:
+        return self._get_attr("rotate", data_type="bool", def_value=False)
+
+    @rotate.setter
+    def rotate(self, value: Optional[bool]):
+        self._set_attr("rotate", value)

flet_map/polygon_layer.py

@@ -0,0 +1,262 @@
+from typing import Any, List, Optional
+
+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.text_style import TextStyle
+from flet.core.types import ColorEnums, ColorValue, StrokeCap, StrokeJoin
+
+
+class PolygonMarker(Control):
+    """
+    A marker for the PolygonLayer.
+
+    -----
+
+    Online docs: https://flet.dev/docs/controls/mappolygonmarker
+    """
+
+    def __init__(
+        self,
+        coordinates: List[MapLatitudeLongitude],
+        label: Optional[str] = None,
+        label_text_style: Optional[TextStyle] = None,
+        border_color: Optional[ColorValue] = None,
+        color: Optional[ColorValue] = None,
+        border_stroke_width: OptionalNumber = None,
+        disable_holes_border: Optional[bool] = None,
+        rotate_label: Optional[bool] = 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.label = label
+        self.label_text_style = label_text_style
+        self.border_color = border_color
+        self.color = color
+        self.border_stroke_width = border_stroke_width
+        self.disable_holes_border = disable_holes_border
+        self.rotate_label = rotate_label
+        self.stroke_cap = stroke_cap
+        self.stroke_join = stroke_join
+
+    def _get_control_name(self):
+        return "map_polygon_marker"
+
+    def before_update(self):
+        super().before_update()
+        self._set_attr_json("coordinates", self.__coordinates)
+        if isinstance(self.__label_text_style, TextStyle):
+            self._set_attr_json("labelTextStyle", self.__label_text_style)
+
+    # 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)
+
+    # 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)
+
+    # label_text_style
+    @property
+    def label_text_style(self) -> Optional[TextStyle]:
+        return self.__label_text_style
+
+    @label_text_style.setter
+    def label_text_style(self, value: Optional[TextStyle]):
+        self.__label_text_style = value
+
+    # rotate_label
+    @property
+    def rotate_label(self) -> bool:
+        return self._get_attr("rotateLabel", data_type="bool", def_value=False)
+
+    @rotate_label.setter
+    def rotate_label(self, value: Optional[bool]):
+        self._set_attr("rotateLabel", value)
+
+    # label
+    @property
+    def label(self) -> Optional[str]:
+        return self._get_attr("label")
+
+    @label.setter
+    def label(self, value: Optional[str]):
+        self._set_attr("label", value)
+
+    # disable_holes_border
+    @property
+    def disable_holes_border(self) -> bool:
+        return self._get_attr("disableHolesBorder", data_type="bool", def_value=False)
+
+    @disable_holes_border.setter
+    def disable_holes_border(self, value: Optional[bool]):
+        self._set_attr("disableHolesBorder", 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)
+
+    # coordinates
+    @property
+    def coordinates(self) -> List[MapLatitudeLongitude]:
+        return self.__coordinates
+
+    @coordinates.setter
+    def coordinates(self, value: List[MapLatitudeLongitude]):
+        self.__coordinates = value
+
+
+class PolygonLayer(MapLayer):
+    """
+    A layer to display PolygonMarkers.
+
+    -----
+
+    Online docs: https://flet.dev/docs/controls/mappolygonlayer
+    """
+
+    def __init__(
+        self,
+        polygons: List[PolygonMarker],
+        polygon_culling: Optional[bool] = None,
+        polygon_labels: Optional[bool] = None,
+        draw_labels_last: Optional[bool] = None,
+        simplification_tolerance: OptionalNumber = None,
+        use_alternative_rendering: 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.polygons = polygons
+        self.polygon_culling = polygon_culling
+        self.polygon_labels = polygon_labels
+        self.draw_labels_last = draw_labels_last
+        self.simplification_tolerance = simplification_tolerance
+        self.use_alternative_rendering = use_alternative_rendering
+
+    def _get_control_name(self):
+        return "map_polygon_layer"
+
+    def _get_children(self):
+        return self.__polygons
+
+    # polygons
+    @property
+    def polygons(self) -> List[PolygonMarker]:
+        return self.__polygons
+
+    @polygons.setter
+    def polygons(self, value: List[PolygonMarker]):
+        self.__polygons = value
+
+    # polygon_culling
+    @property
+    def polygon_culling(self) -> bool:
+        return self._get_attr("polygonCulling", data_type="bool", def_value=False)
+
+    @polygon_culling.setter
+    def polygon_culling(self, value: Optional[bool]):
+        self._set_attr("polygonCulling", value)
+
+    # use_alternative_rendering
+    @property
+    def use_alternative_rendering(self) -> bool:
+        return self._get_attr(
+            "useAlternativeRendering", data_type="bool", def_value=False
+        )
+
+    @use_alternative_rendering.setter
+    def use_alternative_rendering(self, value: Optional[bool]):
+        self._set_attr("useAlternativeRendering", value)
+
+    # polygon_labels
+    @property
+    def polygon_labels(self) -> bool:
+        return self._get_attr("polygonLabels", data_type="bool", def_value=True)
+
+    @polygon_labels.setter
+    def polygon_labels(self, value: Optional[bool]):
+        self._set_attr("polygonLabels", value)
+
+    # simplification_tolerance
+    @property
+    def simplification_tolerance(self) -> float:
+        return self._get_attr(
+            "simplificationTolerance", data_type="float", def_value=0.5
+        )
+
+    @simplification_tolerance.setter
+    def simplification_tolerance(self, value: OptionalNumber):
+        self._set_attr("simplificationTolerance", value)
+
+    # draw_labels_last
+    @property
+    def draw_labels_last(self) -> bool:
+        return self._get_attr("drawLabelsLast", data_type="bool", def_value=False)
+
+    @draw_labels_last.setter
+    def draw_labels_last(self, value: Optional[bool]):
+        self._set_attr("drawLabelsLast", value)