wobbl_tools/pg.py

#!/usr/bin/python3

import pygame
from wobbl_tools import text
from typing import Union, Callable


pygame.init()

log = text.Log()

buttonlist = False
buttons = []


# colors
black = (8, 8, 8)
gray = (40, 40, 40)
light_gray = (128, 128, 128)
white = (250, 250, 250)


default_font = pygame.font.Font(pygame.font.get_default_font(), 16)


class Hover:
    def __init__(self, function=None, ca=None, position: Union[tuple, Callable]=None, size: tuple=None):
        self.function = function
        self.ca = ca
        self.callable_position = None

        if not position is None and not size is None:
            self.x, self.y = position
            self.w, self.h = size

        elif callable(position):
            self.x, self.y = position()
            self.callable_position = position

        self.active = True

    def check(self, mouse_pos: tuple):
        if self.active:
            mx, my = mouse_pos

            if not self.ca is None:
                if self.ca.collidepoint((mx, my)):
                    if self.function is None:
                        return True

                    else:
                        self.function()
                        return True

            else:
                x = self.x
                y = self.y
                w = self.w
                h = self.h

                if mx >= x and mx <= x + w and my >= y and my <= y + h:
                    if self.function is None:
                        return True

                    else:
                        self.function()
                        return True

        return False


class Button:
    def __init__(self, function=None, ca=None, position: Union[tuple, Callable]=None, size: tuple=None, key: int=0):  # ca = collide able, key: 0 = left 1 = mouse wheel pressed 2 = right
        self.callable_position = None

        if not position is None and not size is None:
            self.x, self.y = position
            self.width, self.height = size

        elif callable(position):
            self.x, self.y = position()
            self.callable_position = position

        self.function = function
        self.active = True
        self.ca = ca
        self.key = key

        self.hover = Hover(function, ca, position, size)

        if buttonlist:
            buttons.append(self)

    def check(self, mouse_pos: tuple, pressed):  # check if the button is pressed
        if self.active:
            if pressed[self.key]:
                return self.hover.check(mouse_pos)

        return False


class TextButton:
    def __init__(self, text: str, position: Union[tuple, Callable], surface: pygame.Surface, function=None, key: int=0, text_color: tuple=white, bg_color: tuple=gray, font: pygame.font.Font=default_font, padding: tuple=(8, 8)):
        self.text = text
        self.text_color = text_color
        self.font = font

        self.text_object = self.generate_text(text)
        self.size = (self.text_object.get_width() + padding[0] * 2, self.text_object.get_height() + padding[1] * 2)

        self.surface = surface
        self.function = function
        self.bg_color = bg_color
        self.padding = padding
        self.callable_position = None

        if type(position) is tuple:
            self.position = position

        else:
            self.position = position(size=self.size)
            self.callable_position = position

        self.background = self.generate_background()

        self.button = Button(function, self.background, key=key)

    def generate_text(self, text):
        self.text = text

        return self.font.render(text, True, self.text_color)

    def generate_background(self):
        w, h = self.text_object.get_size()
        w, h = w + self.padding[0] * 2, h + self.padding[1] * 2

        return pygame.Rect(self.position, (w, h))

    def update(self, new_text: str=None, new_pos: Union[tuple, Callable]=None, new_surface: pygame.Surface=None, new_func=None, new_key: int=None, new_text_color: tuple=None, new_bg_color: tuple=None, new_font: pygame.font.Font=None, new_padding: tuple=None):
        if new_text is None:
            new_text = self.text

        if new_text_color is None:
            new_text_color = self.text_color

        if new_bg_color is None:
            new_bg_color = self.bg_color

        if new_font is None:
            new_font = self.font

        if new_padding is None:
            new_padding = self.padding

        self.text = new_text
        self.text_color = new_text_color
        self.bg_color = new_bg_color
        self.font = new_font
        self.padding = new_padding

        self.text_object = self.generate_text(new_text)

        self.size = (self.text_object.get_width() + self.padding[0] * 2, self.text_object.get_height() + self.padding[1] * 2)

        new_callable_pos = None

        if new_pos is None:
            new_pos = self.position
            new_callable_pos = self.callable_position

            if not new_callable_pos is None:
                new_pos = new_callable_pos(self.size)

        elif type(new_pos) is tuple:
            new_callable_pos = None

        else:
            new_pos = new_pos(self.size)
            new_callable_pos = new_pos

        if new_surface is None:
            new_surface = self.surface

        if new_func is None:
            new_func = self.function

        if new_key is None:
            new_key = self.button.key

        self.position = new_pos
        self.callable_position = new_callable_pos
        self.surface = new_surface
        self.function = new_func

        self.background = self.generate_background()

        self.button = Button(new_func, self.background, key=new_key)

    def blit(self, surface: pygame.Surface=None):
        x, y = self.position

        if surface is None:
            surface = self.surface

        pygame.draw.rect(surface, self.bg_color, self.background)
        surface.blit(self.text_object, (x + self.padding[0], y + self.padding[1]))

    def check(self, mouse_pos, pressed):
        return self.button.check(mouse_pos, pressed)


# class HoverTitle:  # coming soon
#     def __init__(self, position: tuple=None, size: tuple=None, page: str=None, popup: str = None, collideable=None, delay: int=20):
#         self.x, self.y = position
#         self.width, self.height = size
#         self.page = page
#         self.popup = popup
#         self.collideable = collideable
#         self.delay = delay


class TextInput:
    def __init__(
            self,
            position: Union[tuple, Callable],
            surface: pygame.Surface,
            width: int=None,
            font: pygame.font.Font=default_font,
            bg_color: tuple=(255, 255, 255),
            text_color: tuple=black,
            desc_text_color: tuple=light_gray,
            desc_text: str="",
            default_text: str="",
            padding: tuple=(8, 8),
            cursor_blink_interval: int=30,
            border_radius: int=-1,
            max_length: int=128
    ):
        self.surface = surface
        self.font = font
        self.bg_color = bg_color
        self.text_color = text_color
        self.desc_text_color = desc_text_color
        self.desc_text = desc_text
        self.text = default_text
        self.padding = padding
        self.focused = True
        self.cursor_blink_interval = cursor_blink_interval
        self.ticks_til_blink = cursor_blink_interval
        self.blink = False
        self.border_radius = border_radius
        self.max_length = max_length
        self.cursor_position = len(default_text)
        
        sx, sy = surface.get_size()
        
        if width is None:
            self.width = round(sx / 4)
            
        else:
            self.width = width
        
        self.description_text_object = font.render(self.desc_text, True, self.desc_text_color)
        self.text_object = font.render(self.text, True, self.text_color)
        self.text_blink_object = font.render(self.text + "|", True, self.text_color)

        self.height = self.text_object.get_height()

        if type(position) is tuple:
            self.position = position

        else:
            self.position = position(size=self.size)
            self.callable_position = position
        
        self.rect = self.generate_rect()

    def generate_rect(self):
        x, y = self.position
        px, py = self.padding
        x -= px
        y -= py

        return pygame.Rect((x, y), (self.width + px * 2, self.height + py * 2))

    def blit(self):
        pygame.draw.rect(self.surface, self.bg_color, self.rect, border_radius=self.border_radius)

        if self.focused:
            if self.blink:
                self.surface.blit(self.text_blink_object, self.position)

            else:
                self.surface.blit(self.text_object, self.position)

    def loop(self):
        """Call this function every tick to make the cursor blink."""

        self.ticks_til_blink -= 1

        if self.ticks_til_blink == -1:
            self.ticks_til_blink = self.cursor_blink_interval
            self.blink = not self.blink

    def keypress(self, event: pygame.event, pressed_keys, special_keys):
        """
        Call this function when a key is pressed to get user input like this:

        for event in pygame.event.get():
         if event.type == pygame.KEYDOWN:
          TextInput.keypress(event, pygame.key.get_pressed(), pygame.key.get_mods())
        """

        if self.max_length is None or len(self.text) <= self.max_length:
            key_unicode = event.unicode
            key = event.key

            if key < 32 or key > 101106 or special_keys & pygame.KMOD_CTRL or special_keys & pygame.KMOD_RCTRL or key > 126 and key < 161:
                if key == pygame.K_BACKSPACE:
                    if self.cursor_position > 0:
                        self.text = text.rsap(self.text, "", self.cursor_position - 1)
                        self.cursor_position -= 1

                elif key == pygame.K_LEFT:
                    if self.cursor_position > 0:
                        self.cursor_position -= 1

                elif key == pygame.K_RIGHT:
                    if self.cursor_position < len(self.text):
                        self.cursor_position += 1

            else:
                self.text = text.asap(self.text, key_unicode, self.cursor_position)
                self.cursor_position += 1

            self.regenerate_objects()

    def regenerate_objects(self):
        self.rect = self.generate_rect()

        self.text_object = self.font.render(self.text, True, self.text_color)
        self.text_blink_object = self.font.render(text.asap(self.text, "|", self.cursor_position), True, self.text_color)

        t_width, t_height = self.text_blink_object.get_size()

        if t_width > self.width:
            self.text_blink_object = crop_surface(self.text_blink_object, (t_width - (t_width - (t_width - self.width)), 0), (t_width - (t_width - self.width), t_height))
            self.text_object = crop_surface(self.text_object, (t_width - (t_width - (t_width - self.width)), 0), (t_width - (t_width - self.width), t_height))


def set_rot_point(img, pos):
    w, h = img.get_size()
    w, h = w * 2, h * 2

    img2 = pygame.Surface((w, h), pygame.SRCALPHA)
    img2.blit(img, (w / 2 - pos[0], h / 2 - pos[1]))
    return img2, (w, h)


def crop_surface(surface: pygame.Surface, position: tuple, size: tuple):
    new_surface = pygame.Surface(size, flags=pygame.SRCALPHA)

    x, y = position
    x = -x
    y = -y

    new_surface.blit(surface, (x, y))

    return new_surface


def bt_from_ca(ca, function):  # bt_from_ca = button from collide able
    return Button(function, ca)


def bt_from_cords(function, position: tuple, size: tuple):
    return Button(function, position=position, size=size)


def check_buttons(mouse_pos, pressed):
    for button in buttons:
        button.check(mouse_pos, pressed)