drawlib 0.2.3.dev2__py3-none-any.whl → 0.2.3.dev4__py3-none-any.whl

drawlib/v0_2/private/smartarts/boxlist.py

@@ -0,0 +1,178 @@
+# Copyright (c) 2024 Yuichi Ito (yuichi@yuichi.com)
+#
+# This software is licensed under the Apache License, Version 2.0.
+# For more information, please visit: https://github.com/yuichi110/drawlib
+#
+# This software is provided "as is", without warranty of any kind,
+# express or implied, including but not limited to the warranties of
+# merchantability, fitness for a particular purpose and noninfringement.
+
+
+"""BoxList implementation module."""
+
+from typing import Any, List, Literal, Optional, Tuple, Union
+
+from drawlib.v0_2.private.core.colors import Colors
+from drawlib.v0_2.private.core.model import ShapeStyle, ShapeTextStyle
+from drawlib.v0_2.private.core.theme import dtheme
+from drawlib.v0_2.private.core_canvas.canvas import rectangle
+from drawlib.v0_2.private.util import error_handler
+
+
+class BoxList:
+    """A class to draw a list of boxes with text, supporting highlighting of certain boxes.
+
+    Args:
+        box_style (Union[str, ShapeStyle, None]): The style for the boxes.
+        text_style (Union[str, ShapeTextStyle, None]): The style for the text inside the boxes.
+        box_highlight_style (Union[str, ShapeStyle, None]): The style for the highlighted boxes.
+        text_highlight_style (Union[str, ShapeTextStyle, None]): The style for the text inside the highlighted boxes.
+    """
+
+    @error_handler
+    def __init__(
+        self,
+        box_style: Union[str, ShapeStyle, None] = None,
+        text_style: Union[str, ShapeTextStyle, None] = None,
+        box_highlight_style: Union[str, ShapeStyle, None] = None,
+        text_highlight_style: Union[str, ShapeTextStyle, None] = None,
+    ) -> None:
+        """Initialize BoxList.
+
+        Args:
+            box_style (Union[str, ShapeStyle, None]): The style for the boxes.
+            text_style (Union[str, ShapeTextStyle, None]): The style for the text inside the boxes.
+            box_highlight_style (Union[str, ShapeStyle, None]): The style for the highlighted boxes.
+            text_highlight_style (Union[str, ShapeTextStyle, None]):
+                    The style for the text inside the highlighted boxes.
+        """
+        if isinstance(box_style, str):
+            box_style = dtheme.rectanglestyles.get(box_style)
+        if box_style is None:
+            box_style = dtheme.rectanglestyles.get()
+        box_style.halign = "center"
+        box_style.valign = "center"
+        self._box_style = box_style
+
+        if isinstance(text_style, str):
+            text_style = dtheme.rectangletextstyles.get(text_style)
+        if text_style is None:
+            text_style = dtheme.rectangletextstyles.get()
+        self._text_style = text_style
+
+        if isinstance(box_highlight_style, str):
+            box_highlight_style = dtheme.rectanglestyles.get(box_highlight_style)
+        if box_highlight_style is None:
+            box_highlight_style = box_style
+        box_highlight_style.halign = "center"
+        box_highlight_style.valign = "center"
+        self._box_highlight_style = box_highlight_style
+
+        if isinstance(text_highlight_style, str):
+            text_highlight_style = dtheme.rectangletextstyles.get(text_highlight_style)
+        if text_highlight_style is None:
+            text_highlight_style = text_style
+        self._text_highlight_style = text_highlight_style
+
+    @error_handler
+    def draw(
+        self,
+        xy: Tuple[float, float],
+        box_width: float,
+        box_height: float,
+        items: List[Any],
+        highlight_indexs: Optional[List[int]] = None,
+        length: Optional[int] = None,
+        align: Literal["left", "right", "bottom", "top"] = "left",
+    ) -> None:
+        """Draws a list of boxes at the specified location.
+
+        Args:
+            xy (Tuple[float, float]): The starting point (x, y) to draw the list of boxes.
+            box_width (float): The width of each box.
+            box_height (float): The height of each box.
+            items (List[Any]): The list of items to be displayed inside the boxes.
+            highlight_indexs (Optional[List[int]]):
+                    The list of indices of the boxes to be highlighted.
+            length (Optional[int]): The total number of boxes to be drawn.
+            align (Literal["left", "right", "bottom", "top"]):
+                    The alignment of the boxes relative to the starting point.
+
+        """
+        if highlight_indexs is None:
+            highlight_indexs = []
+
+        if length is not None:
+            indexs = range(length)
+        else:
+            indexs = range(len(items))
+
+        non_highlight_indexs = [item for item in indexs if item not in highlight_indexs]
+        highlight_indexs = [item for item in indexs if item in highlight_indexs]
+
+        for index in non_highlight_indexs:
+            if index <= len(items) - 1:
+                text = str(items[index])
+            else:
+                text = ""
+
+            self._draw_cell(
+                start_xy=xy,
+                index=index,
+                text=text,
+                box_width=box_width,
+                box_height=box_height,
+                box_style=self._box_style,
+                text_style=self._text_style,
+                align=align,
+            )
+
+        for index in highlight_indexs:
+            if index <= len(items) - 1:
+                text = str(items[index])
+            else:
+                text = ""
+
+            self._draw_cell(
+                start_xy=xy,
+                index=index,
+                text=text,
+                box_width=box_width,
+                box_height=box_height,
+                box_style=self._box_highlight_style,
+                text_style=self._text_highlight_style,
+                align=align,
+            )
+
+    @staticmethod
+    def _draw_cell(
+        start_xy: Tuple[float, float],
+        index: int,
+        text: str,
+        box_width: float,
+        box_height: float,
+        box_style: ShapeStyle,
+        text_style: ShapeTextStyle,
+        align: Literal["left", "right", "bottom", "top"],
+    ) -> None:
+        if align == "left":
+            x = start_xy[0] + box_width * (index + 0.5)
+            y = start_xy[1] + box_height / 2
+        elif align == "right":
+            x = start_xy[0] - box_width * (index + 0.5)
+            y = start_xy[1] + box_height / 2
+        elif align == "bottom":
+            x = start_xy[0] + box_width / 2
+            y = start_xy[1] + box_height * (index + 0.5)
+        else:
+            x = start_xy[0] + box_width / 2
+            y = start_xy[1] - box_height * (index + 0.5)
+
+        rectangle(
+            xy=(x, y),
+            width=box_width,
+            height=box_height,
+            style=box_style,
+            text=text,
+            textstyle=text_style,
+        )

drawlib/v0_2/private/smartarts/bubblespeech.py

@@ -28,9 +28,9 @@ def bubblespeech(
     width: float,
     height: float,
     tail_edge: Literal["left", "top", "right", "bottom"],
-    tail_from_ratio: float,
+    tail_start_ratio: float,
     tail_vertex_xy: Tuple[float, float],
-    tail_to_ratio: float,
+    tail_end_ratio: float,
     style: Union[ShapeStyle, str, None] = None,
     text: str = "",
     textsize: Optional[float] = None,
@@ -43,9 +43,9 @@ def bubblespeech(
         width (float): The width of the bubble.
         height (float): The height of the bubble.
         tail_edge (Literal["left", "top", "right", "bottom"]): The edge on which the tail will be positioned.
-        tail_from_ratio (float): The ratio along the edge where the tail starts.
+        tail_start_ratio (float): The ratio along the edge where the tail starts.
         tail_vertex_xy (Tuple[float, float]): The (x, y) coordinates of the tail's vertex.
-        tail_to_ratio (float): The ratio along the edge where the tail ends.
+        tail_end_ratio (float): The ratio along the edge where the tail ends.
         style (Union[ShapeStyle, str, None], optional): The style of the bubble. Defaults to None.
         text (str, optional): The text to display inside the bubble. Defaults to an empty string.
         textsize (Optional[float], optional): The size of the text. Defaults to None.
@@ -66,33 +66,33 @@ def bubblespeech(
     if textsize is not None:
         textstyle.size = textsize
 
-    if tail_from_ratio > tail_to_ratio:
-        raise ValueError("tail_from_ratio must be smaller than tail_to_ratio.")
-    if tail_to_ratio > 1.0:
-        raise ValueError("tail_from_ratio and tail_to_ratio must be smaller than 1.0")
+    if tail_start_ratio > tail_end_ratio:
+        raise ValueError("tail_start_ratio must be smaller than tail_end_ratio.")
+    if tail_end_ratio > 1.0:
+        raise ValueError("tail_start_ratio and tail_end_ratio must be smaller than 1.0")
 
     x, y = xy
     xys = []
     xys.append((x, y))  # left bottom
     if tail_edge == "left":
-        xys.append((x, y + height * tail_from_ratio))
+        xys.append((x, y + height * tail_start_ratio))
         xys.append(tail_vertex_xy)
-        xys.append((x, y + height * tail_to_ratio))
+        xys.append((x, y + height * tail_end_ratio))
     xys.append((x, y + height))  # left top
     if tail_edge == "top":
-        xys.append((x + width * tail_from_ratio, y + height))
+        xys.append((x + width * tail_start_ratio, y + height))
         xys.append(tail_vertex_xy)
-        xys.append((x + width * tail_to_ratio, y + height))
+        xys.append((x + width * tail_end_ratio, y + height))
     xys.append((x + width, y + height))  # right top
     if tail_edge == "right":
-        xys.append((x + width, y + height * tail_to_ratio))
+        xys.append((x + width, y + height * tail_end_ratio))
         xys.append(tail_vertex_xy)
-        xys.append((x + width, y + height * tail_from_ratio))
+        xys.append((x + width, y + height * tail_start_ratio))
     xys.append((x + width, y))  # right bottom
     if tail_edge == "bottom":
-        xys.append((x + width * tail_to_ratio, y))
+        xys.append((x + width * tail_end_ratio, y))
         xys.append(tail_vertex_xy)
-        xys.append((x + width * tail_from_ratio, y))
+        xys.append((x + width * tail_start_ratio, y))
 
     options = ShapeUtil.get_shape_options(style)
     canvas._artists.append(Polygon(xy=xys, closed=True, **options))

drawlib/v0_2/private/smartarts/bulletpoints.py

@@ -0,0 +1,188 @@
+# Copyright (c) 2024 Yuichi Ito (yuichi@yuichi.com)
+#
+# This software is licensed under the Apache License, Version 2.0.
+# For more information, please visit: https://github.com/yuichi110/drawlib
+#
+# This software is provided "as is", without warranty of any kind,
+# express or implied, including but not limited to the warranties of
+# merchantability, fitness for a particular purpose and noninfringement.
+
+
+"""BulletPoints implementation module."""
+
+import dataclasses
+from typing import Callable, List, Optional, Tuple, Union
+
+from drawlib.v0_2.private.core.colors import Colors
+from drawlib.v0_2.private.core.model import ShapeStyle, TextStyle
+from drawlib.v0_2.private.core.theme import dtheme
+from drawlib.v0_2.private.core_canvas.canvas import circle, text
+from drawlib.v0_2.private.util import error_handler
+
+
+class BulletPoints:
+    """A class to draw a list of bullet points with customizable styles and indentation.
+
+    Args:
+        vertical_margin (float): The vertical space between bullet points.
+        indent_width (float): The width of the indentation for each level.
+        default_style (Union[str, TextStyle, None]): The default text style for the bullet points.
+    """
+
+    @error_handler
+    def __init__(
+        self,
+        vertical_margin: float,
+        indent_width: float,
+        default_style: Union[str, TextStyle, None] = None,
+    ) -> None:
+        """Initialize BulletPoints.
+
+        Args:
+            vertical_margin (float): The vertical space between bullet points.
+            indent_width (float): The width of the indentation for each level.
+            default_style (Union[str, TextStyle, None]): The default text style for the bullet points.
+        """
+        self._vertical_margin = vertical_margin
+        self._indent_width = indent_width
+        if isinstance(default_style, str):
+            default_style = dtheme.textstyles.get(default_style)
+        if default_style is None:
+            default_style = dtheme.textstyles.get()
+        self._default_style = default_style
+
+        self._indent_level = 0
+        self._bullet_texts: List[_BulletPointsText] = []
+        self._bullet_shape_map: dict[int, _BulletPointsShape] = {}
+
+        # set default bullet styles
+        text_color = default_style.color
+        style1 = dtheme.shapestyles.get()
+        style1.lcolor = text_color
+        style1.fcolor = text_color
+        style2 = dtheme.shapestyles.get()
+        style2.lcolor = text_color
+        style2.fcolor = Colors.Transparent
+        self.set_bullet_style(1, circle, style1, args={"radius": 0.5})
+        self.set_bullet_style(2, circle, style2, args={"radius": 0.5})
+
+    @error_handler
+    def set_indent(self, level: int) -> None:
+        """Sets the indentation level for the next bullet point.
+
+        Args:
+            level (int): The indentation level.
+        """
+        self._indent_level = level
+
+    @error_handler
+    def set_bullet_style(
+        self,
+        indent_level: int,
+        function: Callable,
+        style: Union[str, ShapeStyle],
+        args: dict,
+    ) -> None:
+        """Sets the style and function for drawing bullets at a specific indentation level.
+
+        Args:
+            indent_level (int): The indentation level to apply the style to.
+            function (Callable): The function to draw the bullet shape.
+            style (Union[str, ShapeStyle]): The style to apply to the bullet shape.
+            args (dict): Additional arguments to pass to the drawing function.
+        """
+        if isinstance(style, str):
+            style = dtheme.shapestyles.get(style)
+        style.halign = "center"
+        style.valign = "center"
+
+        item = _BulletPointsShape(
+            function=function,
+            style=style,
+            args=args,
+        )
+
+        self._bullet_shape_map[indent_level] = item
+
+    @error_handler
+    def add(
+        self,
+        text: str,
+        style: Union[str, TextStyle, None] = None,
+    ) -> None:
+        """Adds a bullet point with the specified text and style.
+
+        Args:
+            text (str): The text for the bullet point.
+            style (Union[str, TextStyle, None]): The text style for the bullet point.
+        """
+        if isinstance(style, str):
+            style = dtheme.textstyles.get(style)
+        elif style is None:
+            style = self._default_style
+        if style is None:
+            style = dtheme.textstyles.get()
+        style.halign = "left"
+        style.valign = "center"
+
+        self._bullet_texts.append(
+            _BulletPointsText(
+                self._indent_level,
+                text,
+                style,
+            )
+        )
+
+    @error_handler
+    def draw(
+        self,
+        xy: Tuple[float, float],
+    ) -> None:
+        """Draws the list of bullet points starting from the specified location.
+
+        Args:
+            xy (Tuple[float, float]): The starting point (x, y) to draw the bullet points.
+        """
+        y = xy[1]
+        for bullet_text in self._bullet_texts:
+            indent = bullet_text.indent
+            text_ = bullet_text.text
+            textstyle = bullet_text.style
+
+            x = xy[0] + self._indent_width * indent
+            text(
+                xy=(x, y),
+                text=text_,
+                style=textstyle,
+            )
+
+            if indent == 0:
+                ...
+            elif indent not in self._bullet_shape_map:
+                ...
+            else:
+                bps = self._bullet_shape_map[indent]
+                function = bps.function
+                shapestyle = bps.style
+                args = bps.args
+
+                x = xy[0] + self._indent_width * (indent - 0.5)
+                args["xy"] = (x, y)
+                args["style"] = shapestyle
+                function(**args)
+
+            y -= self._vertical_margin
+
+
+@dataclasses.dataclass
+class _BulletPointsShape:
+    function: Callable
+    style: ShapeStyle
+    args: dict
+
+
+@dataclasses.dataclass
+class _BulletPointsText:
+    indent: int
+    text: str
+    style: TextStyle

drawlib/v0_2/private/smartarts/dsart.py

@@ -11,8 +11,15 @@
 
 """Smart art module."""
 
+# Using "bubblespeech as bubblespeech" for explisitly esposing contents.
+# It is good for type checker and IDE.
+# Warnings such as "reportPrivateImportUsage" might be appear if removing it.
+
+from drawlib.v0_2.private.smartarts.boxlist import BoxList as BoxList
 from drawlib.v0_2.private.smartarts.bubblespeech import bubblespeech as bubblespeech
+from drawlib.v0_2.private.smartarts.bulletpoints import BulletPoints as BulletPoints
 from drawlib.v0_2.private.smartarts.gridlayout import GridLayout as GridLayout
 from drawlib.v0_2.private.smartarts.pyramid import Pyramid as Pyramid
 from drawlib.v0_2.private.smartarts.sourcecode import SourceCode as SourceCode
+from drawlib.v0_2.private.smartarts.table import Table as Table
 from drawlib.v0_2.private.smartarts.tree import TreeNode as TreeNode

drawlib/v0_2/private/smartarts/gridlayout.py

@@ -16,11 +16,13 @@ from typing import List, Optional, Tuple, Union
 from drawlib.v0_2.private.core.model import ShapeStyle, ShapeTextStyle
 from drawlib.v0_2.private.core.theme import dtheme
 from drawlib.v0_2.private.core_canvas.canvas import rectangle
+from drawlib.v0_2.private.util import error_handler
 
 
 class GridLayout:
     """Class for rendering multiple rectangles which fit to grid."""
 
+    @error_handler
     def __init__(
         self,
         num_column: int,
@@ -28,6 +30,7 @@ class GridLayout:
         default_r: int = 0,
         default_style: Union[str, ShapeStyle, None] = None,
         default_textstyle: Union[str, ShapeTextStyle, None] = None,
+        default_textangle: Optional[float] = None,
     ) -> None:
         """Initialize class."""
         self._num_column = num_column
@@ -39,9 +42,11 @@ class GridLayout:
         if isinstance(default_textstyle, str):
             default_textstyle = dtheme.rectangletextstyles.get(default_textstyle)
         self._default_textstyle = default_textstyle
+        self._default_textangle = default_textangle
 
         self._items: List[_GridLayoutItem] = []
 
+    @error_handler
     def add(  # noqa: C901
         self,
         column_range: Tuple[int, int],
@@ -50,6 +55,8 @@ class GridLayout:
         style: Union[str, ShapeStyle, None] = None,
         text: str = "",
         textstyle: Union[str, ShapeTextStyle, None] = None,
+        textangle: Optional[float] = None,
+        text_xy_shift: Optional[Tuple[float, float]] = None,
     ) -> None:
         """
         Add an item to the grid layout.
@@ -66,6 +73,10 @@ class GridLayout:
             textstyle (Union[str, ShapeTextStyle, None], optional):
                     The text style of the item. Can be a string key for a predefined text style,
                     a ShapeTextStyle object, or None to use the default text style.
+            textangle (Optional[float], optional):
+                    The angle of the text. Default is None, which is same to 0.
+            text_xy_shift (Optional[Tuple[float, float]], optional):
+                    The XY shift of the text. Default is None, which is same to (0, 0).
 
         Raises:
             ValueError: If the column or row ranges are invalid or out of bounds.
@@ -73,20 +84,22 @@ class GridLayout:
         # validate column
         c1, c2 = column_range
         if c1 > c2:
-            raise ValueError()
+            column_range = (c2, c1)
+            c1, c2 = c2, c1
         if c1 < 0:
-            raise ValueError()
+            raise ValueError("Column range must be between 0 ~ last-index.")
         if c2 > self._num_column:
-            raise ValueError()
+            raise ValueError("Column range must be between 0 ~ last-index.")
 
         # validate row
         r1, r2 = row_range
         if r1 > r2:
-            raise ValueError()
+            row_range = (r2, r1)
+            r1, r2 = r2, r1
         if r1 < 0:
-            raise ValueError()
+            raise ValueError("Row range must be between 0 ~ last-index.")
         if r2 > self._num_column:
-            raise ValueError()
+            raise ValueError("Row range must be between 0 ~ last-index.")
 
         # string style to Style class
         if isinstance(style, str):
@@ -101,6 +114,26 @@ class GridLayout:
             style = self._default_style
         if textstyle is None:
             textstyle = self._default_textstyle
+        if textangle is None:
+            textangle = self._default_textangle
+
+        # set align left bottom
+        if style is None:
+            style = self._default_style
+        if style is None:
+            style = dtheme.rectanglestyles.get()
+        else:
+            style = style.copy()
+        style.halign = "left"
+        style.valign = "bottom"
+
+        # set text angle and xy_shift
+        if textstyle is None:
+            textstyle = dtheme.rectangletextstyles.get()
+        if textangle is not None:
+            textstyle.angle = textangle
+        if text_xy_shift is not None:
+            textstyle.xy_shift = text_xy_shift
 
         # push
         item = _GridLayoutItem(
@@ -113,6 +146,7 @@ class GridLayout:
         )
         self._items.append(item)
 
+    @error_handler
     def draw(
         self,
         xy: Tuple[float, float],
@@ -154,6 +188,7 @@ class GridLayout:
             outer_style=outer_style,
         )
 
+    @error_handler
     def draw_flexible(  # noqa: C901
         self,
         xy: Tuple[float, float],
@@ -182,13 +217,13 @@ class GridLayout:
         """
         # validate
         if len(column_widths) != self._num_column:
-            raise ValueError()
+            raise ValueError('Length of arg "column_widths" does not match to num of columns')
         if len(column_margins) != self._num_column + 1:
-            raise ValueError()
+            raise ValueError('Length of arg "column_margins" does not match to num of columns + 1')
         if len(row_heights) != self._num_row:
-            raise ValueError()
+            raise ValueError('Length of arg "row_heights" does not match to num of rows')
         if len(row_margins) != self._num_row + 1:
-            raise ValueError()
+            raise ValueError('Length of arg "row_margins" does not match to num of rows + 1')
 
         # draw outer rectangle
         if outer_style is not None:
@@ -239,20 +274,6 @@ class GridLayout:
             width = width - margin_left - margin_right
             height = height - margin_bottom - margin_top
 
-            # set align left bottom
-            if style is None:
-                style = self._default_style
-            if style is None:
-                style = dtheme.rectanglestyles.get()
-            else:
-                style = style.copy()
-            style.halign = "left"
-            style.valign = "bottom"
-
-            # apply default text style if specified text style is None
-            if textstyle is None:
-                textstyle = self._default_textstyle
-
             # draw
             rectangle(
                 xy=(xy[0] + lb_xy[0], xy[1] + lb_xy[1]),
@@ -270,6 +291,6 @@ class _GridLayoutItem:
     column_range: Tuple[int, int]
     row_range: Tuple[int, int]
     r: int
-    style: Optional[ShapeStyle]
+    style: ShapeStyle
     text: str
-    textstyle: Optional[ShapeTextStyle]
+    textstyle: ShapeTextStyle