splashscreen-engine 2.0.0__py3-none-any.whl

splashscreen_engine-2.0.0.dist-info/METADATA

@@ -0,0 +1,516 @@
+Metadata-Version: 2.4
+Name: splashscreen-engine
+Version: 2.0.0
+Summary: A module for making Splash Screens with videos, images, loading bars, text rendering, and threaded rendering support for Applications.
+Home-page: https://github.com/NamanChhabra21/splashscreen-engine
+Author: Naman Chhabra
+License: MIT
+Project-URL: Source, https://github.com/NamanChhabra21/splashscreen-engine
+Project-URL: Issues, https://github.com/NamanChhabra21/splashscreen-engine/issues
+Project-URL: Discussions, https://github.com/NamanChhabra21/splashscreen-engine/discussions
+Keywords: pygame,splash-screen,loading-screen,python,gui,video,splashscreen,pygame-gui,window,animation,loading,open-cv,naman,chhabra,splash,pypi,github,screen,how to,module,api,example,documentation,README,tkinter,customtkinter,opencv-python,code,2.0.0,player,tutorial
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pygame
+Requires-Dist: opencv-python
+Requires-Dist: numpy
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# splashscreen-engine
+A module for making Splash Screens with videos, images, loading bars, text rendering, and threaded rendering support for your Applications.
+
+## Sample Preview
+![Preview](https://raw.githubusercontent.com/NamanChhabra21/splashscreen-engine/main/screenshot.png)
+
+## Features
+
+- Optional Title Bar
+- Dynamic Window Resizing
+- Fullscreen Support
+- Background videos
+- Background images
+- Loading bars
+- Text rendering
+- Transparency support
+- Threaded rendering
+- Video looping
+- Simple API
+
+## Installation
+
+```bash
+pip install splashscreen-engine
+```
+OR
+```bash
+pip install splashscreen-engine==2.0.0
+```
+
+## Example
+
+```python
+import splashscreen_engine as splash
+
+screen = splash.Screen()
+screen.size(750,500)
+
+# This Starts The Engine
+screen.start()
+
+# Background Video
+video = splash.BackgroundVideo(
+    screen,
+    "exampleVid.mp4",
+    fps=30,
+    loop=True
+)
+
+video.play()
+
+# Loading Bar
+bar = splash.LoadingBar(screen,add_xy=(0,100)) # By default, position is `center` and add 100 units to y-axis
+bar.place()
+
+# Text `loading`
+text = splash.Text(
+    screen,
+    "Loading...",
+    "impact",
+    20,
+    "down",
+    add_xy=(0,-80) # Place the text downward and subtract 80 units from y-axis
+)
+
+text.show()
+
+# LOADING | you can add your `loading` processes here
+
+a = 0
+
+while not a >= 100:
+
+    a += 0.3
+
+    text.edit(
+        text=f"loading : {round(a,2)}%"
+    )
+
+    bar.set_progress(a)
+
+    screen.wait(0.05)
+
+text.edit(
+    text="loaded : 100%"
+)
+
+screen.wait(3)
+
+# Stop the splash screen after loading
+screen.stop()
+
+
+"""
+if you are using pygame module in your own code,
+use `screen.stop(quit_pygame=False)`
+instead of `screen.stop()`
+"""
+
+# Main Screen Example
+
+import tkinter # pip install tkinter -- used as main screen for example.
+main_screen = tkinter.Tk()
+
+main_screen.geometry("750x500")
+
+main_text = tkinter.Label(
+    main_screen,
+    text="Your Main Screen",
+    font=("impact",40)
+)
+
+main_text.pack()
+
+main_screen.mainloop()
+```
+
+---
+
+## Requirements
+These Modules are automatically installed with : `pip install splashscreen-engine`
+- pygame
+- opencv-python
+- numpy
+
+---
+
+# Functions
+
+### Basic Window
+
+```python
+import splashscreen_engine as splash
+
+screen = splash.Screen()
+
+screen.size(750, 500)
+
+screen.start()
+```
+
+#### Stop and Delete Screen
+
+```python
+screen.stop()
+
+# Use:
+screen.stop(quit_pygame=False)
+
+# if you are using pygame in your own application.
+```
+
+#### Set Size for your window
+
+```python
+screen.size(750,500)
+
+# Arguments:
+# width, height, fullscreen
+
+# OR
+
+screen.size(fullscreen=True)
+```
+
+#### Set title for your window
+
+```python
+screen.title("Your Title")
+```
+
+#### Set Background color
+
+```python
+screen.set_bg_color((255,0,0)) # Red
+```
+
+#### Get Window Size
+
+```python
+width,height = screen.get_size()
+```
+
+---
+### Window with Title bar (optional)
+A title bar is the top bar of a window.
+It usually contains:
+
+- window title
+- window icon # Coming Soon
+- close button
+- minimize button
+- maximize button
+- Note : Clicking on Maximize / Minimize button automatically resizes the screen
+
+---
+![Preview](https://raw.githubusercontent.com/NamanChhabra21/splashscreen-engine/main/screenshot2.png)
+---
+#### To create a Title Bar
+```python
+screen = splash.Screen(title_bar=True)
+```
+#### Functions for Title Bar
+##### To Check if the user clicked on `X` button
+```python
+screen.is_quit()
+```
+##### To check if the user pressed `Esc` Key during fullscreen
+```python
+screen.is_escaped()
+```
+##### Note : These functions are only applicable when `title_bar = True` else it will raise an error.
+---
+### Wait Function
+
+Instead of using `time.sleep()`,
+you can use this function because it prevents
+the `window not responding` issue.
+
+```python
+screen.wait(0.5) # Seconds
+```
+
+---
+
+### Background Video
+
+You can add a video as the background
+of your splash screen using this function.
+
+```python
+video = splash.BackgroundVideo(
+    screen,
+    "exampleVid.mp4",
+    fps=30,
+    loop=True
+)
+
+# loop = True / False
+# default(False)
+
+# fps = int
+# default(30)
+```
+
+#### Play video
+
+```python
+video.play()
+```
+
+#### Pause video
+
+```python
+video.pause()
+```
+
+#### Resume video
+
+```python
+video.resume()
+```
+
+#### Delete video
+
+```python
+video.delete()
+```
+
+#### Transparency
+
+Make your video transparent.
+
+Transparency Level:
+`0 to 255`
+
+Default:
+`120`
+
+```python
+video.transparency(150)
+```
+
+#### Stop Transparency
+
+```python
+video.stop_transparency()
+```
+
+#### Stopping / Resuming Video Loops
+
+```python
+# Loop Video
+video.loop = True
+
+# Stop the Loop
+video.stop_loop()
+
+# OR
+video.loop = False
+```
+
+#### To check whether the video is playing or stopped
+
+```python
+# Returns True if playing else False
+video.playing()
+```
+
+---
+
+### Background Image
+
+You can add an image as the background
+of your splash screen using this function.
+
+```python
+bg_img = splash.BackgroundImage(
+    screen,
+    "YourImage.png"
+)
+
+bg_img.set()
+```
+
+---
+
+### Progress Bar
+
+This function adds a progress bar.
+
+```python
+bar = splash.LoadingBar(
+    screen,
+    position="down",
+    add_xy=(0,-50)
+)
+
+# Arguments:
+# parent, width, height,
+# position, add_xy
+
+bar.place()
+
+# Arguments:
+# colour, loading_colour
+```
+
+#### Available Positions
+
+```python
+"center"
+"right"
+"left"
+"up"
+"down"
+```
+
+
+
+#### Hiding the Progress Bar
+
+```python
+bar.hide()
+```
+
+#### Setting Progress
+
+```python
+bar.set_progress(50)
+```
+
+---
+
+### Text
+
+Adds text on the screen.
+
+```python
+text = splash.Text(
+    screen,
+    "Loading...",
+    "impact",
+    20,
+    position="center",
+    add_xy=(0,0)
+)
+
+# Arguments:
+# parent, text, font,
+# size, position,
+# add_xy, colour
+
+text.show()
+```
+
+#### Available Positions
+
+```python
+"center"
+"right"
+"left"
+"up"
+"down"
+```
+
+#### Show and Hide text
+
+```python
+# Show text
+text.show()
+
+# Hide text
+text.hide()
+```
+
+---
+
+#### Edit The Text | Supports Dynamic Editing
+
+This allows you to edit the text dynamically.
+
+Example:
+Changing:
+`f"Loading {i}%"`
+inside loops.
+
+```python
+text.edit(
+    text = "New Loading Text Added",
+    font = "IMPACT",
+    new_size = 20,
+    position = "center",
+    add_xy = (0,0),
+    colour = (0,255,0)
+)
+```
+---
+### `add_xy` Argument
+
+`add_xy` allows you to move objects relative to their selected position.
+
+Structure:
+
+```python
+add_xy = (x,y)
+```
+
+| Value | Meaning |
+|---|---|
+| Positive `x` | Move Right |
+| Negative `x` | Move Left |
+| Positive `y` | Move Down |
+| Negative `y` | Move Up |
+
+Example:
+
+```python
+text = splash.Text(
+    screen,
+    "Loading...",
+    position="center",
+    add_xy=(0,-100)
+)
+```
+
+This places the text:
+- Horizontally centered
+- 100 pixels above the center
+
+---
+
+## Contributing & Feedback
+
+Discuss approaches, suggest new features,
+report bugs, or share improvements through GitHub
+issues and discussions.
+
+Mail:
+chhabranaman21@gmail.com
+
+---

splashscreen_engine-2.0.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+splashscreen_engine.py,sha256=zGRL7p4TYlTTrAa2S_P94DAA2KrpGCNga7uyGbo_VvQ,19089
+splashscreen_engine-2.0.0.dist-info/METADATA,sha256=B0eLdyeKB0DsLEJLL4jtp0cgrJMQU_YEY-b8_8_-qCQ,8757
+splashscreen_engine-2.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+splashscreen_engine-2.0.0.dist-info/top_level.txt,sha256=ENTn_clsAt7KWt8XYkPBux-bBoKjGlX8DMIKuuKJOjw,20
+splashscreen_engine-2.0.0.dist-info/RECORD,,

splashscreen_engine-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

splashscreen_engine-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+splashscreen_engine

splashscreen_engine.py

@@ -0,0 +1,716 @@
+import os
+import threading
+import time
+
+
+os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
+s = '1'
+os.environ['SDL_VIDEO_CENTERED'] = s
+
+# Modules
+import pygame
+import cv2
+pygame.init()
+
+deleted_by_user = False
+program_stopped = False
+
+def avoid_lag():
+    global deleted_by_user
+    if deleted_by_user:
+        raise RuntimeError("Failed to update UI, the screen is deleted by either you or the user.")
+    pygame.event.pump()
+
+
+
+def draw_loading_bar(screen, bars):
+
+    for bar in bars:
+        if not isinstance(bar, LoadingBar):
+            continue
+
+        if bar.visible:
+            screen_size = screen.get_size()
+            if bar.position == "center":
+                x = (screen_size[0]-bar.width)//2 + bar.add_xy[0] # Center + x , where x can be positive or negative
+                y = (screen_size[1]-bar.height) // 2 + bar.add_xy[1]  # Center + y , where y can be positive or negative
+
+            elif bar.position == "right":
+                x = screen_size[0] - bar.width + bar.add_xy[0]
+                y = (screen_size[1]-bar.height) // 2 + bar.add_xy[1]
+            elif bar.position == "left":
+                x =bar.add_xy[0]
+                y = screen_size[1] // 2 + bar.add_xy[1]
+            elif bar.position == "up":
+                x = (screen_size[0]-bar.width)//2 + bar.add_xy[0]
+                y = bar.height + bar.add_xy[1]
+            elif bar.position == "down":
+                x = (screen_size[0]-bar.width)//2 + bar.add_xy[0]
+                y = screen_size[1]- bar.height + bar.add_xy[1]
+            else:
+                x,y=0,0
+
+            # OUTER BAR
+            pygame.draw.rect(
+                screen,
+                bar.colour,
+                (
+                    x,y,
+                    int(bar.width),
+                    int(bar.height)
+                ),
+                border_radius=10
+            )
+
+            # INNER LOADER
+            pygame.draw.rect(
+                screen,
+                bar.loading_colour,
+                (x,y,
+                    int(
+                        bar.width *
+                        (bar.progress / 100)
+                    ),
+                    int(bar.height)
+                ),
+                border_radius=10
+            )
+
+
+def draw_text(screen, texts):
+    for txt in texts:
+        if not isinstance(txt, Text):
+            continue
+
+        if txt.visible:
+            surface = txt.pg_font.render(txt.text, True, txt.colour)
+
+            screen_size = screen.get_size()
+            if txt.position == "center":
+                x = screen_size[0]//2 + txt.add_xy[0] # Center + x , where x can be positive or negative
+                y = screen_size[1] // 2 + txt.add_xy[1]  # Center + y , where y can be positive or negative
+            elif txt.position == "right":
+                x = screen_size[0] - surface.get_size()[0] + txt.add_xy[0]
+                y = screen_size[1] // 2 + txt.add_xy[1]
+            elif txt.position == "left":
+                x = surface.get_size()[0] + txt.add_xy[0]
+                y = screen_size[1] // 2 + txt.add_xy[1]
+            elif txt.position == "up":
+                x = screen_size[0]//2 + txt.add_xy[0]
+                y = surface.get_size()[1] + txt.add_xy[1]
+            elif txt.position == "down":
+                x = screen_size[0]//2 + txt.add_xy[0]
+                y = screen_size[1]-surface.get_size()[1] + txt.add_xy[1]
+            else:
+                x,y=0,0
+            text_rect = surface.get_rect(center=(x,y))
+            screen.blit(surface,text_rect)
+
+
+one_time_warning = True # A variable used for printing warning inside the size() function | Ensuring doesn't repeat printing the same
+
+class Screen:
+
+    def __init__(self,title_bar=False):
+        # Default Height and Width
+        self.height = 500
+        self.width = 750
+
+        # Fullscreen Variable
+        self.fullscreen = False
+
+        # Screen Info
+        self.info = pygame.display.Info()
+
+        # Caption
+        self.caption = "Splash Screen"
+
+        pygame.display.set_caption(self.caption)
+
+        # Clock
+        self.clock = pygame.time.Clock()
+
+        # Running Variable
+        self.running = False
+        self.stopped = False
+
+        # Screen
+        self.screen = None
+
+        # Background Color
+        self.bgColor = (0, 0, 0)
+
+        # BACKGROUND IMAGE
+        self.current_background = None
+
+        # FOREGROUND VIDEO
+        self.foreground_video = None
+
+        # GLOBAL UI
+        self.ui_elements = []
+
+        self.title_bar = title_bar
+        self.is_escape = False
+
+
+
+    def get_size(self):
+        return self.width,self.height
+
+    def start(self):
+
+        self.running = True
+
+        # CREATING SCREEN
+        if self.fullscreen:
+            # For Full Screen
+            w, h = 0, 0
+            self.is_escape = False # Reset Escape
+        else:
+            # For Normal Window
+            w, h = self.width, self.height
+
+        if not self.title_bar:
+            # Creates window without title Bar
+            self.screen = pygame.display.set_mode((w, h), pygame.NOFRAME)
+        else:
+            # Creates window with title Bar
+            self.screen = pygame.display.set_mode((w, h),pygame.RESIZABLE)
+
+
+        self.screen.fill(self.bgColor)
+
+        pygame.display.update()
+
+        # BACKGROUND MAINLOOP
+        def mainloop():
+            global program_stopped
+
+            if not self.screen:
+                self.start()
+
+            self.running = True
+
+            while self.running and not self.stopped:
+
+                # Updates window size every time you resize
+                if self.title_bar:
+                    size = pygame.display.get_window_size()
+                    self.width,self.height = size[0],size[1]
+                avoid_lag()
+
+                if self.title_bar and self.fullscreen and not self.is_escape:
+                    for event in pygame.event.get():
+                        if event.type == pygame.QUIT:
+
+                            program_stopped = True
+                        if event.type == pygame.KEYDOWN:
+                            if event.key == pygame.K_ESCAPE:
+                                self.is_escape = True
+                                break
+
+                else:
+                    for event in pygame.event.get():
+                        if event.type == pygame.QUIT:
+                            program_stopped = True
+
+
+
+                # CLEAR SCREEN
+                self.screen.fill(self.bgColor)
+
+                # DRAW BACKGROUND IMAGE
+                if self.current_background:
+                    self.screen.blit(self.current_background.image,(0, 0))
+                    draw_loading_bar(self.screen,self.current_background.ui_elements)
+                    draw_text(self.screen,self.current_background.ui_elements)
+
+                # DRAW FOREGROUND VIDEO
+                if self.foreground_video:
+
+                    # DRAW VIDEO FRAME
+                    if self.foreground_video.frame:
+                        self.screen.blit(self.foreground_video.frame,(0, 0))
+
+                    # DRAW VIDEO UI
+                    draw_loading_bar(self.screen,self.foreground_video.ui_elements)
+                    draw_text(self.screen,self.foreground_video.ui_elements)
+
+                # DRAW GLOBAL UI
+                draw_loading_bar(self.screen,self.ui_elements)
+                draw_text(self.screen,self.ui_elements)
+                pygame.display.update()
+
+                self.clock.tick(60)
+            global deleted_by_user
+            deleted_by_user = True
+        threading.Thread(target=mainloop).start() # Starts Mainloop as background process
+
+    def stop(self,quit_pygame = True):
+
+        # Stops the Window
+        self.running = False
+        self.stopped = True
+
+        # STOP VIDEO if playing
+        if self.foreground_video:
+            self.foreground_video.stop = True
+
+        # Checks if user want to quit pygame or not
+        if quit_pygame:
+            pygame.quit()
+
+
+
+    def size(self, width=750, height=500, fullscreen=False):
+
+
+        # Check if width and height is integer and more than 0
+        if (
+                not isinstance(width, int)
+                or
+                not isinstance(height, int)
+                or
+                height < 1
+                or
+                width < 1
+        ):
+            raise TypeError(
+                f"Width and Height must be positive integers. Got width = {width} and height = {height}."
+            )
+
+        global one_time_warning
+        if self.running and one_time_warning:
+            print(
+                "\033[93m"
+                "[WARNING]\n"
+                "size() was called after start().\n\n"
+                "This may cause screen flickering because\n"
+                "the window needs to be recreated.\n\n"
+                "For best results, call size() before start().\n\n"
+                "This warning can be ignored if dynamic\n"
+                "window resizing is intended."
+                "\033[0m"
+            )
+        one_time_warning = False
+
+        self.fullscreen = fullscreen
+
+        if self.fullscreen:
+            self.width,self.height = 0,0
+        else:
+            self.width,self.height = width,height
+        if self.title_bar:
+            screen_mode = pygame.RESIZABLE
+        else:
+            screen_mode = pygame.NOFRAME
+
+        self.screen = pygame.display.set_mode((self.width,self.height),screen_mode)
+
+
+
+
+
+    def title(self, text="Splash Screen"):
+
+        self.caption = text.strip()
+
+        pygame.display.set_caption(self.caption)
+
+    @staticmethod
+    def wait(seconds):
+
+        if seconds <= 1:
+
+            avoid_lag()
+
+            time.sleep(seconds)
+
+            return
+
+        while seconds >= 0:
+
+            avoid_lag()
+
+            time.sleep(0.1)
+
+            seconds -= 0.1
+
+    def set_bg_color(self, color=(0, 0, 0)):
+
+        self.bgColor = color
+
+
+    def is_quit(self):
+        if not self.title_bar:
+            raise RuntimeError("`is_quit` only works if you enable Title Bar.")
+
+        return program_stopped # True if quit else False
+    def is_escaped(self):
+        if not self.title_bar:
+            raise RuntimeError("`is_escaped` only works if Title Bar is enabled.")
+        escape = self.is_escape
+        self.is_escape = False
+        return escape # True if escape else False
+
+
+class BackgroundVideo:
+
+    def __init__(self, screen_object, path, fps=30,loop=False):
+
+        # ONLY SCREEN ALLOWED
+        if not isinstance(screen_object, Screen):
+
+            raise RuntimeError(
+                "You cannot merge backgrounds into other objects"
+            )
+
+        self.parent = screen_object
+
+        self.path = path
+
+        self.video = cv2.VideoCapture(self.path)
+
+        self.stop = False
+
+        self.is_playing = False
+
+        self.loop_thread_video = None
+
+        self.fps = fps
+
+        # Transparency
+        self.transparent = False
+        self.transparent_level = 255
+
+        # CURRENT FRAME
+        self.frame = None
+
+        # UI ELEMENTS
+        self.ui_elements = []
+
+        self.loop = loop
+
+    def play(self):
+
+        self.stop = False
+
+        self.is_playing = True
+
+        # SET FOREGROUND VIDEO
+        self.parent.foreground_video = self
+
+        if not self.video:
+            return
+
+        def thread_video():
+
+            while self.parent.running and not self.stop:
+
+                avoid_lag()
+
+                # READ FRAME
+                success, frame = self.video.read()
+
+                # VIDEO FINISHED
+                if not success:
+
+                    # LOOP VIDEO
+                    if self.loop:
+
+                        self.video.set(
+                            cv2.CAP_PROP_POS_FRAMES,
+                            0
+                        )
+
+                        continue
+
+                    # NORMAL VIDEO END
+                    else:
+
+                        self.is_playing = False
+
+                        # REMOVE FRAME ONLY
+                        self.frame = None
+
+                        break
+
+                # CONVERT COLORS
+                frame = cv2.cvtColor(
+                    frame,
+                    cv2.COLOR_BGR2RGB
+                )
+
+                # FULLSCREEN
+                if self.parent.fullscreen:
+
+                    frame = cv2.resize(
+                        frame,
+                        (
+                            self.parent.info.current_w,
+                            self.parent.info.current_h
+                        )
+                    )
+
+                # NORMAL WINDOW
+                else:
+
+                    frame = cv2.resize(
+                        frame,
+                        (
+                            self.parent.width,
+                            self.parent.height
+                        )
+                    )
+
+                # CREATE SURFACE
+                surface = pygame.surfarray.make_surface(
+                    frame.swapaxes(0, 1)
+                )
+
+                # TRANSPARENCY
+                if self.transparent:
+
+                    surface.set_alpha(
+                        self.transparent_level
+                    )
+
+                # STORE FRAME
+                self.frame = surface
+
+                self.parent.clock.tick(self.fps)
+
+        self.loop_thread_video = threading.Thread(
+            target=thread_video
+        )
+
+        self.loop_thread_video.start()
+
+    def pause(self):
+
+        self.stop = True
+
+        self.is_playing = False
+
+    def resume(self):
+
+        self.stop = False
+
+        self.play()
+
+    def delete(self):
+
+        self.pause()
+
+        self.video.set(
+            cv2.CAP_PROP_POS_FRAMES,
+            0
+        )
+
+        self.frame = None
+
+    def transparency(self, level=120):
+
+        if level < 0:
+            level = 0
+
+        if level > 255:
+            level = 255
+
+        self.transparent = True
+
+        self.transparent_level = level
+
+    def stop_transparency(self):
+
+        self.transparent = False
+
+    def stop_loop(self):
+        self.loop = False
+
+    def playing(self):
+        return self.playing
+
+
+class BackgroundImage:
+
+    def __init__(self, parent, path):
+
+        # ONLY SCREEN ALLOWED
+        if not isinstance(parent, Screen):
+
+            raise RuntimeError(
+                "You cannot merge backgrounds into other objects"
+            )
+
+        self.parent = parent
+
+        self.path = path
+
+        self.ui_elements = []
+
+        image = pygame.image.load(self.path)
+
+        # FULLSCREEN
+        if self.parent.fullscreen:
+
+            image = pygame.transform.scale(
+                image,
+                (
+                    self.parent.info.current_w,
+                    self.parent.info.current_h
+                )
+            )
+
+        # NORMAL WINDOW
+        else:
+
+            image = pygame.transform.scale(
+                image,
+                (
+                    self.parent.width,
+                    self.parent.height
+                )
+            )
+
+        self.image = image
+
+    def set(self):
+
+        self.parent.current_background = self
+
+
+class LoadingBar:
+
+    def __init__(self, parent, width=None, height=None,position="center",add_xy = (0,0)):
+
+        check_valid_pos(position,"LoadingBar")
+        self.position = position.lower()
+        self.add_xy = add_xy  # adds / subtract the value of x-axis and y-axis from the chosen position
+
+        self.parent = parent
+
+        # AUTO REGISTER
+        if hasattr(
+                self.parent,
+                "ui_elements"
+        ):
+
+            self.parent.ui_elements.append(
+                self
+            )
+
+        self.screen_dimension = (
+            pygame.display.get_window_size()
+        )
+
+        # RESPONSIVE WIDTH
+        if width is None:
+
+            width = (
+                self.screen_dimension[0] * 0.6
+            )
+
+        # RESPONSIVE HEIGHT
+        if height is None:
+
+            height = (
+                self.screen_dimension[1] * 0.015
+            )
+
+        self.width = width
+        self.height = height
+        self.colour = (255, 255, 255)
+
+        self.loading_colour = (0, 255, 0)
+
+        self.visible = False
+
+        self.progress = 0
+
+    def place(
+            self,
+            colour=(255, 255, 255),
+            loading_colour=(0, 255, 0)
+    ):
+
+        self.colour = colour
+
+        self.loading_colour = loading_colour
+
+        self.visible = True
+
+    def hide(self):
+
+        self.visible = False
+
+    def set_progress(self, value):
+
+        # CLAMP
+        if value < 0:
+            value = 0
+
+        if value > 100:
+            value = 100
+
+        self.progress = value
+
+def check_valid_pos(string,object_type):
+    available_position = ["right", "left", "down", "up", "center",None]
+    if string not in available_position:
+        available_position.pop() # Remove `None` for displaying Available positions
+        raise RuntimeError(f"`{object_type}` object got unknown positional argument. Please choose from {available_position}")
+
+class Text:
+
+    def __init__(self,parent,text="Your Text Here",font=None,size=20,position="center",add_xy = (0,0),colour=(255, 255, 255)):
+
+        check_valid_pos(position,"Text")
+        self.position = position.lower()
+        self.add_xy = add_xy  # adds / subtract the value of x-axis and y-axis from the chosen position
+
+
+        self.parent = parent
+        self.text = text
+        self.font = font
+        self.size = size
+        self.position = position
+        self.colour = colour
+        # DEFAULT FONT
+        self.pg_font = pygame.font.SysFont(self.font,self.size)
+        self.visible = True
+
+
+
+        # REGISTER
+        if hasattr(self.parent, "ui_elements"):
+            self.parent.ui_elements.append(self)
+
+    def edit(self,text=None,font=None,new_size=None,position=None,add_xy=None,colour=None):
+
+        if text is not None:
+            self.text = text
+
+        if font is not None:
+            self.font = font
+            # UPDATE FONT
+            self.pg_font = pygame.font.SysFont(self.font, self.size)
+
+        if new_size is not None:
+            self.size = new_size
+
+        if position is not None:
+            self.position = position
+
+        if add_xy is not None:
+            self.add_xy = add_xy
+
+        if colour is not None:
+            self.colour = colour
+
+    def hide(self):
+        self.visible = False
+
+    def show(self):
+        self.visible = True
+