wobbl_tools/pg.py

#!/usr/bin/python3

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

pygame.init()

log = text.Log()

buttonlist = False
buttons = []


# colors
gray = (40, 40, 40)
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:
                print(type(self.ca))
                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

        print(type(ca))

        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: int=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 * 2, self.text_object.get_height() + padding * 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 * 2, h + self.padding * 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: int=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 * 2, self.text_object.get_height() + self.padding * 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, y + self.padding))

    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


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)