sketchingpy.sketch2dapp

   1"""Pygame-based renderer for Sketchingpy.
   2
   3License:
   4    BSD
   5"""
   6
   7import contextlib
   8import copy
   9import math
  10import typing
  11
  12import PIL.Image
  13import PIL.ImageFont
  14
  15with contextlib.redirect_stdout(None):
  16    import pygame
  17    import pygame.draw
  18    import pygame.image
  19    import pygame.key
  20    import pygame.locals
  21    import pygame.mouse
  22    import pygame.time
  23
  24
  25ui_available = False
  26try:
  27    import pygame_gui  # type: ignore
  28    import pygame_gui.windows  # type: ignore
  29    import sketchingpy.pygame_prompt  # type: ignore
  30    ui_available = True
  31except:
  32    pass
  33
  34import sketchingpy.abstracted
  35import sketchingpy.const
  36import sketchingpy.control_struct
  37import sketchingpy.data_struct
  38import sketchingpy.local_data_struct
  39import sketchingpy.pillow_util
  40import sketchingpy.sketch2d_keymap
  41import sketchingpy.state_struct
  42import sketchingpy.transform
  43
  44DEFAULT_FPS = 20
  45MANUAL_OFFSET = True
  46OPTIONAL_SKETCH_CALLBACK = typing.Optional[typing.Callable[[sketchingpy.abstracted.Sketch], None]]
  47
  48
  49class Sketch2DApp(sketchingpy.abstracted.Sketch):
  50    """Create a new Pygame-based Sketch."""
  51
  52    def __init__(self, width: int, height: int, title: typing.Optional[str] = None,
  53        loading_src: typing.Optional[str] = None):
  54        """Create a enw Pygame-based sketch.
  55
  56        Args:
  57            width: The width of the sketch in pixels. This will be used for window width.
  58            height: The height of the sketch in pixels. This will be used for window height.
  59            title: Starting title for the application.
  60            loading_src: ID for loading screen. Ignored, reserved for future use.
  61        """
  62        super().__init__()
  63
  64        # System params
  65        self._width = width
  66        self._height = height
  67
  68        # Callbacks
  69        self._callback_step: OPTIONAL_SKETCH_CALLBACK = None
  70        self._callback_quit: OPTIONAL_SKETCH_CALLBACK = None
  71
  72        # User configurable state
  73        self._state_frame_rate = DEFAULT_FPS
  74
  75        # Buffers
  76        self._internal_surface = None
  77        self._output_surface = None
  78        self._buffers: typing.Dict[str, pygame.Surface] = {}
  79
  80        # Internal state
  81        self._internal_pre_show_actions: typing.List[typing.Callable] = []
  82        self._internal_quit_requested = False
  83        self._internal_clock = pygame.time.Clock()
  84        self._transformer = sketchingpy.transform.Transformer()
  85        self._transformer_stack: typing.List[sketchingpy.transform.Transformer] = []
  86        self._dialog_layer: typing.Optional['AppDialogLayer'] = None
  87
  88        # Inputs
  89        self._mouse = PygameMouse()
  90        self._keyboard = PygameKeyboard()
  91
  92        # Internal struct
  93        self._struct_event_handlers = {
  94            pygame.KEYDOWN: lambda x: self._process_key_down(x),
  95            pygame.KEYUP: lambda x: self._process_key_up(x),
  96            pygame.MOUSEBUTTONDOWN: lambda x: self._process_mouse_down(x),
  97            pygame.MOUSEBUTTONUP: lambda x: self._process_mouse_up(x),
  98            pygame.locals.QUIT: lambda x: self._process_quit(x)
  99        }
 100
 101        # Default window properties
 102        self.set_title('Sketchingpy Sketch' if title is None else title)
 103
 104    ##########
 105    # Buffer #
 106    ##########
 107
 108    def create_buffer(self, name: str, width: int, height: int,
 109        background: typing.Optional[str] = None):
 110        def execute():
 111            has_alpha = self._get_is_color_transparent(background)
 112            self._buffers[name] = self._make_shape_surface(
 113                pygame.Rect(0, 0, width, height),
 114                0,
 115                has_alpha=has_alpha
 116            )
 117            if not has_alpha:
 118                self._buffers[name].fill(pygame.Color(background))
 119
 120        if self._internal_surface is None:
 121            self._internal_pre_show_actions.append(execute)
 122        else:
 123            execute()
 124
 125    def enter_buffer(self, name: str):
 126        def execute():
 127            self._internal_surface = self._buffers[name]
 128
 129        if self._internal_surface is None:
 130            self._internal_pre_show_actions.append(execute)
 131        else:
 132            execute()
 133
 134    def exit_buffer(self):
 135        def execute():
 136            self._internal_surface = self._output_surface
 137
 138        if self._internal_surface is None:
 139            self._internal_pre_show_actions.append(execute)
 140        else:
 141            execute()
 142
 143    def draw_buffer(self, x: float, y: float, name: str):
 144        def execute():
 145            target_surface = self._buffers[name]
 146
 147            original_rect = target_surface.get_rect()
 148            rect = pygame.Rect(
 149                original_rect.x,
 150                original_rect.y,
 151                original_rect.width,
 152                original_rect.height
 153            )
 154            rect.left = x
 155            rect.top = y
 156
 157            self._blit_with_transform(
 158                target_surface,
 159                rect.centerx,
 160                rect.centery,
 161                self._transformer.quick_copy()
 162            )
 163
 164        if self._internal_surface is None:
 165            self._internal_pre_show_actions.append(execute)
 166        else:
 167            execute()
 168
 169    ############
 170    # Controls #
 171    ############
 172
 173    def get_keyboard(self) -> typing.Optional[sketchingpy.control_struct.Keyboard]:
 174        return self._keyboard
 175
 176    def get_mouse(self) -> typing.Optional[sketchingpy.control_struct.Mouse]:
 177        return self._mouse
 178
 179    ########
 180    # Data #
 181    ########
 182
 183    def get_data_layer(self) -> typing.Optional[sketchingpy.data_struct.DataLayer]:
 184        return sketchingpy.local_data_struct.LocalDataLayer()
 185
 186    ###########
 187    # Dialogs #
 188    ###########
 189
 190    def get_dialog_layer(self) -> typing.Optional[sketchingpy.dialog_struct.DialogLayer]:
 191        if not ui_available:
 192            return None
 193
 194        if self._dialog_layer is None:
 195            self._dialog_layer = AppDialogLayer(self)
 196
 197        return self._dialog_layer
 198
 199    ###########
 200    # Drawing #
 201    ###########
 202
 203    def clear(self, color_hex: str):
 204        if self._internal_surface is None:
 205            self._internal_pre_show_actions.append(lambda: self.clear(color_hex))
 206            return
 207
 208        self._internal_surface.fill(pygame.Color(color_hex))
 209
 210    def draw_arc(self, x1: float, y1: float, x2: float, y2: float, a1: float,
 211        a2: float):
 212        state_machine = self._get_current_state_machine()
 213
 214        stroke_enabled = state_machine.get_stroke_enabled()
 215        fill_enabled = state_machine.get_fill_enabled()
 216        stroke_native = state_machine.get_stroke_native()
 217        fill_native = state_machine.get_fill_native()
 218        stroke_weight = state_machine.get_stroke_weight()
 219
 220        mode_native = state_machine.get_arc_mode_native()
 221        rect = self._build_rect_with_mode(x1, y1, x2, y2, mode_native)
 222
 223        a1_rad = self._convert_to_radians(a1)
 224        a2_rad = self._convert_to_radians(a2)
 225
 226        transformer = self._transformer.quick_copy()
 227
 228        def execute_draw():
 229            pillow_util_image = sketchingpy.pillow_util.make_arc_image(
 230                rect.x,
 231                rect.y,
 232                rect.w,
 233                rect.h,
 234                a1_rad,
 235                a2_rad,
 236                stroke_enabled,
 237                fill_enabled,
 238                self._to_pillow_rgba(stroke_native) if stroke_enabled else None,
 239                self._to_pillow_rgba(fill_native) if fill_enabled else None,
 240                stroke_weight
 241            )
 242
 243            native_image = self._convert_pillow_image(pillow_util_image.get_image())
 244
 245            self._blit_with_transform(
 246                native_image,
 247                rect.centerx,
 248                rect.centery,
 249                transformer
 250            )
 251
 252        if self._internal_surface is None:
 253            self._internal_pre_show_actions.append(execute_draw)
 254        else:
 255            execute_draw()
 256
 257    def draw_ellipse(self, x1: float, y1: float, x2: float, y2: float):
 258        state_machine = self._get_current_state_machine()
 259
 260        stroke_enabled = state_machine.get_stroke_enabled()
 261        fill_enabled = state_machine.get_fill_enabled()
 262        stroke_native = state_machine.get_stroke_native()
 263        fill_native = state_machine.get_fill_native()
 264        stroke_weight = state_machine.get_stroke_weight()
 265
 266        mode_native = state_machine.get_ellipse_mode_native()
 267        rect = self._build_rect_with_mode(x1, y1, x2, y2, mode_native)
 268
 269        transformer = self._transformer.quick_copy()
 270
 271        def execute_draw():
 272            pillow_util_image = sketchingpy.pillow_util.make_ellipse_image(
 273                rect.x,
 274                rect.y,
 275                rect.w,
 276                rect.h,
 277                stroke_enabled,
 278                fill_enabled,
 279                self._to_pillow_rgba(stroke_native) if stroke_enabled else None,
 280                self._to_pillow_rgba(fill_native) if fill_enabled else None,
 281                stroke_weight
 282            )
 283
 284            native_image = self._convert_pillow_image(pillow_util_image.get_image())
 285
 286            self._blit_with_transform(
 287                native_image,
 288                rect.centerx,
 289                rect.centery,
 290                transformer
 291            )
 292
 293        if self._internal_surface is None:
 294            self._internal_pre_show_actions.append(execute_draw)
 295        else:
 296            execute_draw()
 297
 298    def draw_line(self, x1: float, y1: float, x2: float, y2: float):
 299        state_machine = self._get_current_state_machine()
 300        if not state_machine.get_stroke_enabled():
 301            return
 302
 303        stroke_color = state_machine.get_stroke_native()
 304        stroke_weight = state_machine.get_stroke_weight_native()
 305
 306        transformer = self._transformer.quick_copy()
 307
 308        def execute_draw():
 309            min_x = min([x1, x2])
 310            max_x = max([x1, x2])
 311            width = max_x - min_x + 2 * stroke_weight
 312
 313            min_y = min([y1, y2])
 314            max_y = max([y1, y2])
 315            height = max_y - min_y + 2 * stroke_weight
 316
 317            rect = pygame.Rect(0, 0, width, height)
 318            target_surface = self._make_shape_surface(rect, stroke_weight)
 319
 320            def adjust(target):
 321                return (
 322                    target[0] - min_x + stroke_weight - 1,
 323                    target[1] - min_y + stroke_weight - 1,
 324                )
 325
 326            pygame.draw.line(
 327                target_surface,
 328                stroke_color,
 329                adjust((x1, y1)),
 330                adjust((x2, y2)),
 331                width=stroke_weight
 332            )
 333
 334            center_x = (max_x + min_x) / 2
 335            center_y = (max_y + min_y) / 2
 336            self._blit_with_transform(target_surface, center_x, center_y, transformer)
 337
 338        if self._internal_surface is None:
 339            self._internal_pre_show_actions.append(execute_draw)
 340        else:
 341            execute_draw()
 342
 343    def draw_rect(self, x1: float, y1: float, x2: float, y2: float):
 344        state_machine = self._get_current_state_machine()
 345
 346        stroke_enabled = state_machine.get_stroke_enabled()
 347        fill_enabled = state_machine.get_fill_enabled()
 348        stroke_native = state_machine.get_stroke_native()
 349        fill_native = state_machine.get_fill_native()
 350        stroke_weight = state_machine.get_stroke_weight()
 351
 352        mode_native = state_machine.get_rect_mode_native()
 353        rect = self._build_rect_with_mode(x1, y1, x2, y2, mode_native)
 354
 355        transformer = self._transformer.quick_copy()
 356
 357        def execute_draw():
 358            pillow_util_image = sketchingpy.pillow_util.make_rect_image(
 359                rect.x,
 360                rect.y,
 361                rect.w,
 362                rect.h,
 363                stroke_enabled,
 364                fill_enabled,
 365                self._to_pillow_rgba(stroke_native) if stroke_enabled else None,
 366                self._to_pillow_rgba(fill_native) if fill_enabled else None,
 367                stroke_weight
 368            )
 369
 370            native_image = self._convert_pillow_image(pillow_util_image.get_image())
 371
 372            self._blit_with_transform(
 373                native_image,
 374                rect.centerx,
 375                rect.centery,
 376                transformer
 377            )
 378
 379        if self._internal_surface is None:
 380            self._internal_pre_show_actions.append(execute_draw)
 381        else:
 382            execute_draw()
 383
 384    def draw_shape(self, shape: sketchingpy.shape_struct.Shape):
 385        if not shape.get_is_finished():
 386            raise RuntimeError('Finish your shape before drawing.')
 387
 388        state_machine = self._get_current_state_machine()
 389
 390        stroke_enabled = state_machine.get_stroke_enabled()
 391        fill_enabled = state_machine.get_fill_enabled()
 392        stroke_native = state_machine.get_stroke_native()
 393        fill_native = state_machine.get_fill_native()
 394        stroke_weight = state_machine.get_stroke_weight()
 395
 396        transformer = self._transformer.quick_copy()
 397
 398        def execute_draw():
 399            pillow_util_image = sketchingpy.pillow_util.make_shape_image(
 400                shape,
 401                stroke_enabled,
 402                fill_enabled,
 403                self._to_pillow_rgba(stroke_native) if stroke_enabled else None,
 404                self._to_pillow_rgba(fill_native) if fill_enabled else None,
 405                stroke_weight
 406            )
 407
 408            native_image = self._convert_pillow_image(pillow_util_image.get_image())
 409
 410            min_x = shape.get_min_x()
 411            max_x = shape.get_max_x()
 412            center_x = (max_x + min_x) / 2
 413
 414            min_y = shape.get_min_y()
 415            max_y = shape.get_max_y()
 416            center_y = (max_y + min_y) / 2
 417
 418            self._blit_with_transform(
 419                native_image,
 420                center_x,
 421                center_y,
 422                transformer
 423            )
 424
 425        if self._internal_surface is None:
 426            self._internal_pre_show_actions.append(execute_draw)
 427        else:
 428            execute_draw()
 429
 430    def draw_text(self, x: float, y: float, content: str):
 431        content = str(content)
 432        state_machine = self._get_current_state_machine()
 433
 434        stroke_enabled = state_machine.get_stroke_enabled()
 435        fill_enabled = state_machine.get_fill_enabled()
 436        stroke_native = state_machine.get_stroke_native()
 437        fill_native = state_machine.get_fill_native()
 438        stroke_weight = state_machine.get_stroke_weight()
 439
 440        text_font = state_machine.get_text_font_native()
 441        fill_pillow = self._to_pillow_rgba(fill_native)
 442        stroke_pillow = self._to_pillow_rgba(stroke_native)
 443
 444        align_info = state_machine.get_text_align_native()
 445        anchor_str = align_info.get_horizontal_align() + align_info.get_vertical_align()
 446
 447        transformer = self._transformer.quick_copy()
 448
 449        def execute_draw():
 450            pillow_util_image = sketchingpy.pillow_util.make_text_image(
 451                x,
 452                y,
 453                content,
 454                text_font,
 455                stroke_enabled,
 456                fill_enabled,
 457                stroke_pillow,
 458                fill_pillow,
 459                stroke_weight,
 460                anchor_str
 461            )
 462
 463            native_image = self._convert_pillow_image(pillow_util_image.get_image())
 464
 465            self._blit_with_transform(
 466                native_image,
 467                pillow_util_image.get_x() + pillow_util_image.get_width() / 2,
 468                pillow_util_image.get_y() + pillow_util_image.get_height() / 2,
 469                transformer
 470            )
 471
 472        if self._internal_surface is None:
 473            self._internal_pre_show_actions.append(execute_draw)
 474        else:
 475            execute_draw()
 476
 477    ##########
 478    # Events #
 479    ##########
 480
 481    def on_step(self, callback: sketchingpy.abstracted.StepCallback):
 482        self._callback_step = callback
 483
 484    def on_quit(self, callback: sketchingpy.abstracted.QuitCallback):
 485        self._callback_quit = callback
 486
 487    #########
 488    # Image #
 489    #########
 490
 491    def get_image(self, src: str) -> sketchingpy.abstracted.Image:
 492        return PygameImage(src)
 493
 494    def draw_image(self, x: float, y: float, image: sketchingpy.abstracted.Image):
 495        if not image.get_is_loaded():
 496            return
 497
 498        transformer = self._transformer.quick_copy()
 499
 500        image_mode_native = self._get_current_state_machine().get_image_mode_native()
 501
 502        def execute_draw():
 503            rect = self._build_rect_with_mode(
 504                x,
 505                y,
 506                image.get_width(),
 507                image.get_height(),
 508                image_mode_native
 509            )
 510
 511            surface = image.get_native()
 512            self._blit_with_transform(surface, rect.centerx, rect.centery, transformer)
 513
 514        if self._internal_surface is None:
 515            self._internal_pre_show_actions.append(execute_draw)
 516        else:
 517            execute_draw()
 518
 519    def save_image(self, path: str):
 520        def execute_save():
 521            pygame.image.save(self._internal_surface, path)
 522
 523        if self._internal_surface is None:
 524            self._internal_pre_show_actions.append(execute_save)
 525            self.show_and_quit()
 526        else:
 527            execute_save()
 528
 529    #########
 530    # State #
 531    #########
 532
 533    def push_transform(self):
 534        self._transformer_stack.append(copy.deepcopy(self._transformer))
 535
 536    def pop_transform(self):
 537        if len(self._transformer_stack) == 0:
 538            raise RuntimeError('Transformation stack empty.')
 539
 540        self._transformer = self._transformer_stack.pop()
 541
 542    ##########
 543    # System #
 544    ##########
 545
 546    def get_native(self):
 547        if self._internal_surface is None:
 548            raise RuntimeError('Need to show sketch first before surface is available.')
 549
 550        return self._internal_surface
 551
 552    def set_fps(self, rate: int):
 553        self._state_frame_rate = rate
 554
 555    def set_title(self, title: str):
 556        def execute():
 557            pygame.display.set_caption(title)
 558
 559        if self._internal_surface is None:
 560            self._internal_pre_show_actions.append(execute)
 561        else:
 562            execute()
 563
 564    def quit(self):
 565        self._internal_quit_requested = True
 566
 567    def show(self, ax=None):
 568        self._show_internal(ax=ax, quit_immediately=False)
 569
 570    def show_and_quit(self, ax=None):
 571        self._show_internal(ax=ax, quit_immediately=True)
 572
 573    #############
 574    # Transform #
 575    #############
 576
 577    def translate(self, x: float, y: float):
 578        self._transformer.translate(x, y)
 579
 580    def rotate(self, angle_mirror: float):
 581        angle = -1 * angle_mirror
 582        angle_rad = self._convert_to_radians(angle)
 583        self._transformer.rotate(angle_rad)
 584
 585    def scale(self, scale: float):
 586        self._transformer.scale(scale)
 587
 588    ###########
 589    # Support #
 590    ###########
 591
 592    def _get_window_size(self) -> typing.Tuple[int, int]:
 593        return (self._width, self._height)
 594
 595    def _show_internal(self, ax=None, quit_immediately=False):
 596        self._snapshot_time()
 597        pygame.init()
 598        self._internal_surface = pygame.display.set_mode((self._width, self._height))
 599        self._output_surface = self._internal_surface
 600
 601        for action in self._internal_pre_show_actions:
 602            action()
 603
 604        self._inner_loop(quit_immediately=quit_immediately)
 605
 606    def _inner_loop(self, quit_immediately=False):
 607        clock = pygame.time.Clock()
 608
 609        while not self._internal_quit_requested:
 610            time_delta = clock.tick(60) / 1000.0
 611
 612            for event in pygame.event.get():
 613                self._process_event(event)
 614                if self._dialog_layer:
 615                    self._dialog_layer.get_manager().process_events(event)
 616                    dialog = self._dialog_layer.get_dialog()
 617                    try:
 618                        if dialog is not None and event.ui_element == dialog:
 619                            self._dialog_layer.report_close(event)
 620                    except AttributeError:
 621                        pass
 622
 623            if self._dialog_layer:
 624                self._dialog_layer.get_manager().update(time_delta)
 625
 626            if self._callback_step is not None:
 627                self._callback_step(self)
 628
 629            if self._dialog_layer:
 630                self._dialog_layer.get_manager().draw_ui(self._internal_surface)
 631
 632            pygame.display.update()
 633            self._internal_clock.tick(self._state_frame_rate)
 634
 635            if quit_immediately:
 636                self._internal_quit_requested = True
 637
 638        if self._callback_quit is not None:
 639            self._callback_quit(self)
 640
 641    def _process_event(self, event):
 642        if event.type not in self._struct_event_handlers:
 643            return
 644
 645        self._struct_event_handlers[event.type](event)
 646
 647    def _process_quit(self, event):
 648        self._internal_quit_requested = True
 649
 650    def _process_mouse_down(self, event):
 651        self._mouse.report_mouse_down(event)
 652
 653    def _process_mouse_up(self, event):
 654        self._mouse.report_mouse_up(event)
 655
 656    def _process_key_down(self, event):
 657        self._keyboard.report_key_down(event)
 658
 659    def _process_key_up(self, event):
 660        self._keyboard.report_key_up(event)
 661
 662    def _create_state_machine(self) -> sketchingpy.state_struct.SketchStateMachine:
 663        return PygameSketchStateMachine()
 664
 665    def _make_shape_surface(self, rect: pygame.Rect, stroke_weight: float,
 666        has_alpha: bool = True) -> pygame.Surface:
 667        if has_alpha:
 668            return pygame.Surface((rect.w + stroke_weight, rect.h + stroke_weight), pygame.SRCALPHA)
 669        else:
 670            return pygame.Surface((rect.w + stroke_weight, rect.h + stroke_weight))
 671
 672    def _zero_rect(self, rect: pygame.Rect) -> pygame.Rect:
 673        return pygame.Rect(0, 0, rect.w, rect.h)
 674
 675    def _build_rect_with_mode(self, x1: float, y1: float, x2: float, y2: float,
 676        native_mode: int) -> pygame.Rect:
 677        if native_mode == sketchingpy.const.CENTER:
 678            start_x = x1 - math.floor(x2 / 2)
 679            start_y = y1 - math.floor(y2 / 2)
 680            width = x2
 681            height = y2
 682        elif native_mode == sketchingpy.const.RADIUS:
 683            start_x = x1 - x2
 684            start_y = y1 - y2
 685            width = x2 * 2
 686            height = y2 * 2
 687        elif native_mode == sketchingpy.const.CORNER:
 688            start_x = x1
 689            start_y = y1
 690            width = x2
 691            height = y2
 692        elif native_mode == sketchingpy.const.CORNERS:
 693            (x1, y1, x2, y2) = sketchingpy.abstracted.reorder_coords(x1, y1, x2, y2)
 694            start_x = x1
 695            start_y = y1
 696            width = x2 - x1
 697            height = y2 - y1
 698        else:
 699            raise RuntimeError('Unknown mode: ' + str(native_mode))
 700
 701        return pygame.Rect(start_x, start_y, width, height)
 702
 703    def _draw_primitive(self, x1: float, y1: float, x2: float, y2: float,
 704        mode: str, native_mode, draw_method):
 705        state_machine = self._get_current_state_machine()
 706        has_fill = state_machine.get_fill_enabled()
 707        fill_color = state_machine.get_fill_native()
 708        has_stroke = state_machine.get_stroke_enabled()
 709        stroke_color = state_machine.get_stroke_native()
 710        rect = self._build_rect_with_mode(x1, y1, x2, y2, native_mode)
 711        stroke_weight = state_machine.get_stroke_weight_native()
 712
 713        transformer = self._transformer.quick_copy()
 714
 715        def execute_draw_piece(color, strategy):
 716            target_surface = self._make_shape_surface(rect, stroke_weight)
 717            rect_adj = self._zero_rect(rect)
 718
 719            strategy(target_surface, rect_adj)
 720
 721            self._blit_with_transform(
 722                target_surface,
 723                rect.centerx,
 724                rect.centery,
 725                transformer
 726            )
 727
 728        def execute_draw():
 729            if has_fill:
 730                execute_draw_piece(
 731                    fill_color,
 732                    lambda surface, rect: draw_method(
 733                        surface,
 734                        fill_color,
 735                        self._offset_fill_weight(rect, stroke_weight),
 736                        0
 737                    )
 738                )
 739
 740            if has_stroke:
 741                execute_draw_piece(
 742                    stroke_color,
 743                    lambda surface, rect: draw_method(
 744                        surface,
 745                        stroke_color,
 746                        self._offset_stroke_weight(rect, stroke_weight),
 747                        stroke_weight
 748                    )
 749                )
 750
 751        if self._internal_surface is None:
 752            self._internal_pre_show_actions.append(execute_draw)
 753            return
 754        else:
 755            execute_draw()
 756
 757    def _to_pillow_rgba(self, target: pygame.Color):
 758        return (target.r, target.g, target.b, target.a)
 759
 760    def _convert_pillow_image(self, target: PIL.Image.Image) -> pygame.Surface:
 761        return pygame.image.fromstring(
 762            target.tobytes(),
 763            target.size,
 764            target.mode  # type: ignore
 765        ).convert_alpha()
 766
 767    def _blit_with_transform(self, surface: pygame.Surface, x: float, y: float,
 768        transformer: sketchingpy.transform.Transformer):
 769        start_rect = surface.get_rect()
 770        start_rect.centerx = x  # type: ignore
 771        start_rect.centery = y  # type: ignore
 772
 773        transformed_center = transformer.transform(
 774            start_rect.centerx,
 775            start_rect.centery
 776        )
 777
 778        has_scale = transformed_center.get_scale() != 1
 779        has_rotation = transformed_center.get_rotation() != 0
 780        has_content_transform = has_scale or has_rotation
 781        if has_content_transform:
 782            angle = transformed_center.get_rotation()
 783            angle_transform = math.degrees(angle)
 784            scale = transformed_center.get_scale()
 785            surface = pygame.transform.rotozoom(surface, angle_transform, scale)
 786            end_rect = surface.get_rect()
 787        else:
 788            end_rect = start_rect
 789
 790        end_rect.centerx = transformed_center.get_x()  # type: ignore
 791        end_rect.centery = transformed_center.get_y()  # type: ignore
 792
 793        assert self._internal_surface is not None
 794        self._internal_surface.blit(surface, (end_rect.x, end_rect.y))
 795
 796
 797class PygameSketchStateMachine(sketchingpy.state_struct.SketchStateMachine):
 798    """Implementation of SketchStateMachine for Pygame types."""
 799
 800    def __init__(self):
 801        """Create a new state machine for Pygame-based sketches."""
 802        super().__init__()
 803        self._fill_native = pygame.Color(super().get_fill())
 804        self._stroke_native = pygame.Color(super().get_stroke())
 805        self._font_cache = {}
 806        self._text_align_native = self._transform_text_align(super().get_text_align_native())
 807
 808    def set_fill(self, fill: str):
 809        super().set_fill(fill)
 810        self._fill_native = pygame.Color(super().get_fill())
 811
 812    def get_fill_native(self):
 813        return self._fill_native
 814
 815    def set_stroke(self, stroke: str):
 816        super().set_stroke(stroke)
 817        self._stroke_native = pygame.Color(super().get_stroke())
 818
 819    def get_stroke_native(self):
 820        return self._stroke_native
 821
 822    def get_text_font_native(self):
 823        font = self.get_text_font()
 824        key = '%s.%d' % (font.get_identifier(), font.get_size())
 825
 826        if key not in self._font_cache:
 827            new_font = PIL.ImageFont.truetype(font.get_identifier(), font.get_size())
 828            self._font_cache[key] = new_font
 829
 830        return self._font_cache[key]
 831
 832    def set_text_align(self, text_align: sketchingpy.state_struct.TextAlign):
 833        super().set_text_align(text_align)
 834        self._text_align_native = self._transform_text_align(super().get_text_align_native())
 835
 836    def get_text_align_native(self):
 837        return self._text_align_native
 838
 839    def _transform_text_align(self,
 840        text_align: sketchingpy.state_struct.TextAlign) -> sketchingpy.state_struct.TextAlign:
 841
 842        HORIZONTAL_ALIGNS = {
 843            sketchingpy.const.LEFT: 'l',
 844            sketchingpy.const.CENTER: 'm',
 845            sketchingpy.const.RIGHT: 'r'
 846        }
 847
 848        VERTICAL_ALIGNS = {
 849            sketchingpy.const.TOP: 't',
 850            sketchingpy.const.CENTER: 'm',
 851            sketchingpy.const.BASELINE: 's',
 852            sketchingpy.const.BOTTOM: 'b'
 853        }
 854
 855        return sketchingpy.state_struct.TextAlign(
 856            HORIZONTAL_ALIGNS[text_align.get_horizontal_align()],
 857            VERTICAL_ALIGNS[text_align.get_vertical_align()]
 858        )
 859
 860
 861class PygameImage(sketchingpy.abstracted.Image):
 862    """Strategy implementation for Pygame images."""
 863
 864    def __init__(self, src: str):
 865        """Create a new image.
 866
 867        Args:
 868            src: Path to the image.
 869        """
 870        super().__init__(src)
 871        self._native = pygame.image.load(self.get_src())
 872        self._converted = False
 873
 874    def get_width(self) -> float:
 875        return self._native.get_rect().width
 876
 877    def get_height(self) -> float:
 878        return self._native.get_rect().height
 879
 880    def resize(self, width: float, height: float):
 881        self._native = pygame.transform.scale(self._native, (width, height))
 882
 883    def get_native(self):
 884        if not self._converted:
 885            self._native.convert_alpha()
 886
 887        return self._native
 888
 889    def get_is_loaded(self):
 890        return True
 891
 892
 893class PygameMouse(sketchingpy.control_struct.Mouse):
 894    """Strategy implementation for Pygame-based mouse access."""
 895
 896    def __init__(self):
 897        """Create a new mouse strategy using Pygame."""
 898        super().__init__()
 899        self._press_callback = None
 900        self._release_callback = None
 901
 902    def get_pointer_x(self):
 903        return pygame.mouse.get_pos()[0]
 904
 905    def get_pointer_y(self):
 906        return pygame.mouse.get_pos()[1]
 907
 908    def get_buttons_pressed(self) -> sketchingpy.control_struct.Buttons:
 909        is_left_pressed = pygame.mouse.get_pressed()[0]
 910        is_right_pressed = pygame.mouse.get_pressed()[2]
 911        buttons_clicked = []
 912
 913        if is_left_pressed:
 914            buttons_clicked.append(sketchingpy.const.MOUSE_LEFT_BUTTON)
 915
 916        if is_right_pressed:
 917            buttons_clicked.append(sketchingpy.const.MOUSE_RIGHT_BUTTON)
 918
 919        return map(lambda x: sketchingpy.control_struct.Button(x), buttons_clicked)
 920
 921    def on_button_press(self, callback: sketchingpy.control_struct.MouseCallback):
 922        self._press_callback = callback
 923
 924    def on_button_release(self, callback: sketchingpy.control_struct.MouseCallback):
 925        self._release_callback = callback
 926
 927    def report_mouse_down(self, event):
 928        if self._press_callback is None:
 929            return
 930
 931        if event.button == 1:
 932            button = sketchingpy.control_struct.Button(sketchingpy.const.MOUSE_LEFT_BUTTON)
 933            self._press_callback(button)
 934        elif event.button == 3:
 935            button = sketchingpy.control_struct.Button(sketchingpy.const.MOUSE_RIGHT_BUTTON)
 936            self._press_callback(button)
 937
 938    def report_mouse_up(self, event):
 939        if self._release_callback is None:
 940            return
 941
 942        if event.button == 1:
 943            button = sketchingpy.control_struct.Button(sketchingpy.const.MOUSE_LEFT_BUTTON)
 944            self._release_callback(button)
 945        elif event.button == 3:
 946            button = sketchingpy.control_struct.Button(sketchingpy.const.MOUSE_RIGHT_BUTTON)
 947            self._release_callback(button)
 948
 949
 950class PygameKeyboard(sketchingpy.control_struct.Keyboard):
 951    """Strategy implementation for Pygame-based keyboard access."""
 952
 953    def __init__(self):
 954        """Create a new keyboard strategy using Pygame."""
 955        super().__init__()
 956        self._pressed = set()
 957        self._press_callback = None
 958        self._release_callback = None
 959
 960    def get_keys_pressed(self) -> sketchingpy.control_struct.Buttons:
 961        return map(lambda x: sketchingpy.control_struct.Button(x), self._pressed)
 962
 963    def on_key_press(self, callback: sketchingpy.control_struct.KeyboardCallback):
 964        self._press_callback = callback
 965
 966    def on_key_release(self, callback: sketchingpy.control_struct.KeyboardCallback):
 967        self._release_callback = callback
 968
 969    def report_key_down(self, event):
 970        mapped = sketchingpy.sketch2d_keymap.KEY_MAP.get(event.key, None)
 971
 972        if mapped is None:
 973            return
 974
 975        self._pressed.add(mapped)
 976
 977        if self._press_callback is not None:
 978            button = sketchingpy.control_struct.Button(mapped)
 979            self._press_callback(button)
 980
 981    def report_key_up(self, event):
 982        mapped = sketchingpy.sketch2d_keymap.KEY_MAP.get(event.key, None)
 983
 984        if mapped is None:
 985            return
 986
 987        self._pressed.remove(mapped)
 988
 989        if self._release_callback is not None:
 990            button = sketchingpy.control_struct.Button(mapped)
 991            self._release_callback(button)
 992
 993
 994class AppDialogLayer(sketchingpy.dialog_struct.DialogLayer):
 995    """Dialog / simple UI layer for local apps."""
 996
 997    def __init__(self, sketch: Sketch2DApp):
 998        """"Initialize tkinter but hide the root window."""
 999        self._sketch = sketch
1000        self._sketch_size = self._sketch._get_window_size()
1001        self._manager = pygame_gui.UIManager(self._sketch_size)
1002        self._callback = None  # type: ignore
1003        self._dialog = None  # type: ignore
1004
1005    def get_manager(self):
1006        return self._manager
1007
1008    def get_dialog(self):
1009        return self._dialog
1010
1011    def report_close(self, event):
1012        if self._callback:
1013            self._callback(event)
1014
1015    def show_alert(self, message: str, callback: typing.Optional[typing.Callable[[], None]] = None):
1016        self._dispose_dialog()
1017        self._set_dialog(pygame_gui.windows.UIMessageWindow(
1018            rect=pygame.Rect(
1019                self._sketch_size[0] / 2 - 150,
1020                self._sketch_size[1] / 2 - 150,
1021                300,
1022                300
1023            ),
1024            html_message=message,
1025            manager=self._manager
1026        ))
1027
1028        def outer_callback(event):
1029            if event.type == pygame_gui._constants.UI_BUTTON_PRESSED and callback:
1030                callback()
1031
1032        self._callback = outer_callback  # type: ignore
1033
1034    def show_prompt(self, message: str,
1035        callback: typing.Optional[typing.Callable[[str], None]] = None):
1036        self._set_dialog(sketchingpy.pygame_prompt.PygameGuiPrompt(  # type: ignore
1037            rect=pygame.Rect(
1038                self._sketch_size[0] / 2 - 150,
1039                self._sketch_size[1] / 2 - 150,
1040                300,
1041                300
1042            ),
1043            action_long_desc=message,
1044            manager=self._manager,
1045            window_title='Prompt'
1046        ))
1047
1048        def outer_callback(event):
1049            if event.type == pygame_gui._constants.UI_CONFIRMATION_DIALOG_CONFIRMED:
1050                callback(str(self._dialog.get_text()))
1051
1052        self._callback = outer_callback  # type: ignore
1053
1054    def get_file_save_location(self,
1055        callback: typing.Optional[typing.Callable[[str], None]] = None):
1056        self._dispose_dialog()
1057        self._set_dialog(pygame_gui.windows.ui_file_dialog.UIFileDialog(
1058            rect=pygame.Rect(
1059                self._sketch_size[0] / 2 - 150,
1060                self._sketch_size[1] / 2 - 150,
1061                300,
1062                300
1063            ),
1064            manager=self._manager,
1065            allow_existing_files_only=False,
1066            window_title='Save'
1067        ))
1068        self._callback = self._make_file_dialog_callback(callback)  # type: ignore
1069
1070    def get_file_load_location(self,
1071        callback: typing.Optional[typing.Callable[[str], None]] = None):
1072        self._dispose_dialog()
1073        self._set_dialog(pygame_gui.windows.ui_file_dialog.UIFileDialog(
1074            rect=pygame.Rect(
1075                self._sketch_size[0] / 2 - 150,
1076                self._sketch_size[1] / 2 - 150,
1077                300,
1078                300
1079            ),
1080            manager=self._manager,
1081            allow_existing_files_only=False,
1082            window_title='Load'
1083        ))
1084        self._callback = self._make_file_dialog_callback(callback)  # type: ignore
1085
1086    def _make_file_dialog_callback(self, inner_callback):
1087        def callback(event):
1088            if event.type == pygame_gui.UI_FILE_DIALOG_PATH_PICKED:
1089                inner_callback(str(self._dialog.current_file_path))
1090
1091        return callback
1092
1093    def _dispose_dialog(self):
1094        if self._dialog:
1095            self._dialog.kill()
1096
1097    def _set_dialog(self, new_dialog):
1098        self._dialog = new_dialog  # type: ignore