VIStk 0.3.12.14__py3-none-any.whl

VIStk/Structures/screen.py

@@ -0,0 +1,153 @@
+import os
+import json
+import shutil
+import re
+import glob
+from VIStk.Structures.VINFO import *
+import tkinter as TK
+
+class Screen(VINFO):
+    """A VIS screen object
+    """
+    def __init__(self,name:str,script:str,release:bool=False,icon:str=None,exists:bool=True,desc:str=None):
+        super().__init__()
+        self.name=name
+        self.script=script
+        self.release=release
+        self.icon=icon
+        self.path = self.p_screens+"/"+self.name
+        self.m_path = self.p_modules+"/"+self.name
+
+        if not exists:
+            with open(self.p_sinfo,"r") as f:
+                info = json.load(f)
+
+            info[self.title]["Screens"][self.name] = {"script":script,"release":release}
+            if not icon == None:
+                info[self.title]["Screens"][self.name]["icon"] = icon
+            
+            if not desc == None:
+                info[self.title]["Screens"][self.name]["desc"] = desc
+            else:
+                info[self.title]["Screens"][self.name]["desc"] = "A VIS Created Executable"
+
+            info[self.title]["Screens"][self.name]["version"] = "1.0.0"#always making first major version of screen
+
+            info[self.title]["Screens"][self.name]["current"] = None#always making first major version of screen
+
+            with open(self.p_sinfo,"w") as f:
+                json.dump(info,f,indent=4)
+
+            shutil.copyfile(self.p_templates+"/screen.txt",self.p_project+"/"+script)
+            os.mkdir(self.p_screens+"/"+self.name)
+            os.mkdir(self.p_modules+"/"+self.name)
+
+        with open(self.p_sinfo,"r") as f:
+                info = json.load(f)
+        self.desc = info[self.title]["Screens"][self.name]["desc"]
+        self.s_version = info[self.title]["Screens"][self.name]["version"]
+        self.current = info[self.title]["Screens"][self.name]["current"]
+        
+    def addElement(self,element:str) -> int:
+        if validName(element):
+            if not os.path.exists(self.path+"/f_"+element+".py"):
+                shutil.copyfile(self.p_templates+"/f_element.txt",self.path+"/f_"+element+".py")
+                print(f"Created element f_{element}.py in {self.path}")
+                self.patch(element)
+            if not os.path.exists(self.m_path+"/m_"+element+".py"):
+                with open(self.m_path+"/m_"+element+".py", "w"): pass
+                print(f"Created module m_{element}.py in {self.m_path}")
+            return 1
+        else:
+            return 0
+        
+    def addMenu(self,menu:str) -> int:
+        pass #will be command line menu creation tool
+
+    def patch(self,element:str) -> int:
+        """Patches up the template after its copied
+        """
+        if os.path.exists(self.path+"/f_"+element+".py"):
+            with open(self.path+"/f_"+element+".py","r") as f:
+                text = f.read()
+            text = text.replace("<frame>","f_"+element)
+            with open(self.path+"/f_"+element+".py","w") as f:
+                f.write(text)
+            print(f"patched f_{element}.py")
+            return 1
+        else:
+            print(f"Could not patch, element does not exist.")
+            return 0
+    
+    def stitch(self) -> int:
+        """Connects screen elements to a screen
+        """
+        with open(self.p_project+"/"+self.script,"r") as f: text = f.read()
+        stitched = []
+        #Elements
+        pattern = r"#Screen Elements.*#Screen Grid"
+
+        elements = glob.glob(self.path+'/f_*')#get all elements
+        for i in range(0,len(elements),1):#iterate into module format
+            elements[i] = elements[i].replace("\\","/")
+            elements[i] = elements[i].replace(self.path+"/","Screens."+self.name+".")[:-3]
+            stitched.append(elements[i])
+        #combine and change text
+        elements = "from " + " import *\nfrom ".join(elements) + " import *\n"
+        text = re.sub(pattern, "#Screen Elements\n" + elements + "\n#Screen Grid", text, flags=re.DOTALL)
+
+        #Modules
+        pattern = r"#Screen Modules.*#Handle Arguments"
+
+        modules = glob.glob(self.m_path+'/m_*')#get all modules
+        for i in range(0,len(modules),1):#iterate into module format
+            modules[i] = modules[i].replace("\\","/")
+            modules[i] = modules[i].replace(self.m_path+"/","modules."+self.name+".")[:-3]
+            stitched.append(modules[i])
+        #combine and change text
+        modules = "from " + " import *\nfrom ".join(modules) + " import *\n"
+        text = re.sub(pattern, "#Screen Modules\n" + modules + "\n#Handle Arguments", text, flags=re.DOTALL)
+
+        #write out
+        with open(self.p_project+"/"+self.script,"w") as f:
+            f.write(text)
+        print("Stitched: ")
+        for i in stitched:
+            print(f"\t{i} to {self.name}")
+
+    def syncVersion(self) -> int:
+        """Syncs the version stored in sinfo with the version in memory
+        """
+        with open(self.p_sinfo,"r") as f:
+            info = json.load(f)
+        info[self.title]["Screens"][self.name]["current"] = self.current
+        with open(self.p_sinfo,"w") as f:
+            json.dump(info,f)
+        return 1
+
+    def crntVersion(self) -> int:
+        """Checks if the version needs to be synced and returns 1 if its synced
+        """
+        if not self.s_version == self.current:
+            self.current = self.version
+            self.syncVersion()
+            return 1
+        else:
+            return 0
+
+    def unLoad(self,root:TK.Tk) -> int:
+        """Unloads all elements on the screen"""
+        for element in root.winfo_children():
+            try:
+                element.destroy()
+            except: pass 
+            #might fail to delete widgets that get deleted by earlier deletions
+
+    def load(self) -> int:
+        """Loads a new screen onto the root"""
+        #should just need to run the python file now
+        #cant do that through subprocess.call when compiling
+        #can make python dlls? something like this for each screen
+        #then itll be easy to load/unload elements
+        #can even have these dlls take a parameter for the root
+        #then we can do splitscreen and windowed things if we want

VIStk/Templates/collect.txt

@@ -0,0 +1,5 @@
+coll = COLLECT($insert$
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    name='$version$')

VIStk/Templates/f_element.txt

@@ -0,0 +1,25 @@
+#Default Imports
+from tkinter import *
+from tkinter import ttk
+from Screens.root import *
+#File Specific Imports
+
+#Create Frame
+<frame> = ttk.Frame(root)
+<frame>.grid(column=0,row=0,columnspan=1,rowspan=1,sticky=(N, S, E, W))
+
+#Configure Frame Grid
+<frame>.columnconfigure(1,weight=1)
+<frame>.rowconfigure(1,weight=1)
+
+#Declare Stringvars
+
+#Button Commands and Functions
+
+#Navigation
+
+#########################
+#####Visual Elements#####
+#########################
+
+#Element Descriptions

VIStk/Templates/screen.txt

@@ -0,0 +1,43 @@
+#Default Imports
+from tkinter import *
+from tkinter import ttk
+from Screens.root import *
+import sys
+#File Specific Imports
+
+#Configure Screen
+w = 1080
+h = 720
+ws = root.winfo_screenwidth()
+hs = root.winfo_screenheight()
+x = (ws/2) - (w/2)
+y = (hs/2) - (h/2)
+root.geometry('%dx%d+%d+%d' % (w, h, x, y))
+root.title("Placeholder Title")
+root.minsize(1080,720)
+#root.iconbitmap("<project>/Images/Icons/<some_icon>")
+
+#Screen Elements
+
+#Screen Grid
+root.grid_columnconfigure(0,weight=1)
+root.grid_rowconfigure(0,weight=1)
+
+#Screen Modules
+
+#Handle Arguments
+
+#Define Loop Modules
+def loop():
+    #screen modules run here
+    1+1
+
+#Update Loop
+while True: 
+    try:
+        if root.winfo_exists():
+            try:loop()
+            except:pass
+            root.update()
+    except:
+        break

VIStk/Templates/spec.txt

@@ -0,0 +1,33 @@
+$name$_a = Analysis(
+    ['../$file$'],
+    pathex=[],
+    binaries=[],
+    datas=[],
+    hiddenimports=[],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    noarchive=False,
+    optimize=0,)
+$name$_pyz = PYZ($name$_a.pure)
+$name$_exe = EXE(
+    $name$_pyz,
+    $name$_a.scripts,
+    $name$_a.binaries,
+    $name$_a.datas,
+    [],
+    exclude_binaries=True,
+    name='$name$',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    console=False,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+    icon=['../Icons/$icon$.ico'],
+    version='$meta$')

VIStk/Templates/version.txt

@@ -0,0 +1,30 @@
+# UTF-8
+
+VSVersionInfo(
+  ffi=FixedFileInfo(
+    filevers=($sM$,$sm$,$sp$,0),
+    prodvers=($M$,$m$,$p$,0),
+    mask=0x3f,
+    flags=0x0,
+    OS=0x40004,
+    fileType=0x1,
+    subtype=0x0,
+    date=(0, 0)
+    ),
+  kids=[
+    StringFileInfo(
+      [
+      StringTable(
+        u'040904B0',
+        [StringStruct(u'CompanyName', u'$company$'),
+        StringStruct(u'FileDescription', u'$desc$'),
+        StringStruct(u'FileVersion', u'$sM$.$sm$.$sp$'),
+        StringStruct(u'InternalName', u'$title$-$name$'),
+        StringStruct(u'LegalCopyright', u'Copyright © $year$ $company$'),
+        StringStruct(u'OriginalFilename', u'$name$.exe'),
+        StringStruct(u'ProductName', u'$name$'),
+        StringStruct(u'ProductVersion', u'$M$.$m$.$p$')])
+      ]), 
+    VarFileInfo([VarStruct(u'Translation', [1033, 1200])])
+  ]
+)

VIStk/VIS.py

@@ -0,0 +1,54 @@
+import sys
+import os
+import zipfile
+from importlib import metadata
+from VIStk.Structures import *
+
+inp = sys.argv
+print(f"VIS Version {metadata.version("VIStk")}")
+
+
+#Copied from source https://stackoverflow.com/a/75246706
+def unzip_without_overwrite(src_path, dst_dir):
+    with zipfile.ZipFile(src_path, "r") as zf:
+        for member in zf.infolist():
+            file_path = os.path.join(dst_dir, member.filename)
+            if not os.path.exists(file_path):
+                zf.extract(member, dst_dir)
+def __main__():
+    match inp[1]:
+        case "new"|"New"|"N"|"n":#Create a new VIS project
+            project = VINFO()
+
+        case "add" | "Add" | "a" | "A":
+            project = Project()
+            match inp[2]:
+                case "screen" | "Screen" | "s" | "S":
+                    if not inp[3] == None:
+                        screen = project.verScreen(inp[3])
+                        if len(inp) >= 5:
+                            match inp[4]:
+                                case "menu" | "Menu" | "m" | "M":
+                                    screen.addMenu(inp[5])
+                                case "elements" | "Elements" | "e" | "E":
+                                    for i in inp[5].split("-"):
+                                        screen.addElement(i)
+                                    screen.stitch()
+                        else:
+                            project.newScreen(inp[3])
+
+        case "stitch" | "Stitch" | "s" | "S":
+            project = Project()
+            screen = project.getScreen(inp[2])
+            if not screen == None:
+                screen.stitch()
+            else:
+                print("Screen does not exist")
+
+        case "release" | "Release" | "r" | "R":
+            if len(inp) == 4:
+                #newRelease(inp[2],inp[3])
+                pass
+            else:
+                #newRelease(inp[2])
+                pass

VIStk/Widgets/_MenuItem.py

@@ -0,0 +1,36 @@
+from tkinter import *
+from tkinter import ttk
+import subprocess
+import os
+
+class MenuItem():
+    """Each item in the menu is created from the corresponding .json file. Each path should be given relative to xyz/WOM/
+    """
+    def __init__(self,parent:Frame|Toplevel|LabelFrame|Tk,path,nav,*args,**kwargs):
+        """Create an item in a row on the menu
+        Args:
+            root (Tk): Master root for destruction on redirect
+            _root (Toplevel): Toplevel object to create menu items in
+            path (str): Name of .exe or absolute path to python script
+            nav (str): Navigation character to click button
+        """
+        self.button = Button(master=parent, *args, **kwargs)
+        self.parent = parent
+        self.root = parent.winfo_toplevel()
+        self.path = path
+        self.nav = nav
+        self.button.config(command = self.itemPath)
+        enter = lambda event: event.widget.configure(background="dodger blue")
+        leave = lambda event: event.widget.configure(background="gray94")
+        self.button.bind("<Enter>", enter)
+        self.button.bind("<Leave>", leave)
+        #self.button.pack()
+
+    def itemPath(self):
+        """Opens the given path or exe for the button
+        """
+        if ".exe" in self.path:
+            os.startfile(self.path)
+        else:
+            subprocess.call("pythonw.exe "+self.path)
+        self.root.destroy()

VIStk/Widgets/_MenuWindow.py

@@ -0,0 +1,22 @@
+from VIStk.Objects import *
+from VIStk.Widgets._VISMenu import VISMenu
+from tkinter import *
+
+class MenuWindow(SubRoot):
+    def __init__(self,parent:Tk|Toplevel,path:str,*args,**kwargs):
+        super().__init__(*args,**kwargs)
+
+        #Ensure visibility
+        self.focus_force()
+
+        #Load Menu
+        self.menu = VISMenu(self, path)
+        
+        #SubWindow Geometry
+        self.update()
+        self.WindowGeometry.getGeometry(True)
+        self.WindowGeometry.setGeometry(width=self.winfo_width(),
+                                        height=self.winfo_height(),
+                                        align="center",
+                                        size_style="window_relative",
+                                        window_ref=parent)

VIStk/Widgets/_QuestionWindow.py

@@ -0,0 +1,89 @@
+from typing import Literal
+from tkinter import *
+from tkinter import ttk
+from VIStk.Objects import SubRoot
+
+class QuestionWindow(SubRoot):
+    """An empty popout window"""
+    def __init__(self, question:str|list[str], answer:str, parent:Toplevel|Tk, ycommand=None, droplist:list=None, *args,**kwargs):
+        """Will create a question window
+            y = yes
+            n = no
+            r = return
+            u = continue
+            b = back
+            x = close
+            c = confirm
+            d = dropdown
+        """
+        super().__init__(*args,**kwargs)
+        cs = len(list(answer))
+
+        for i in range(0,cs,1):
+            self.columnconfigure(i,weight=1)
+
+        #Resolve Question
+        if isinstance(question, str):
+            self.rowconfigure(0, weight=1)
+            rs = 1
+            Label(self, text=question, anchor="w").grid(row=0,column=0,columnspan=cs,sticky=(N,S,E,W))
+        else:
+            rs = len(question)
+            for i in range(0,rs,1):
+                self.rowconfigure(i, weight=1)
+                Label(self, text=question[i], anchor="w").grid(row=i,column=0,columnspan=cs,sticky=(N,S,E,W))
+        self.rowconfigure(rs, weight=1)
+
+        #Resolve Answer
+        self.elements = list(answer)
+
+        self.screen_elements = []
+        for i in range(0,len(self.elements),1):
+            match self.elements[i]:
+                case "y":
+                    self.screen_elements.append(Button(self, text="Yes", command = lambda: self.ycom(ycommand)))
+                    self.screen_elements[i].grid(row=rs,column=i,sticky=(N,S,E,W))
+                case "n":
+                    self.screen_elements.append(Button(self, text="No", command = self.xcom))
+                    self.screen_elements[i].grid(row=rs,column=i,sticky=(N,S,E,W))
+                case "r":
+                    self.screen_elements.append(Button(self, text="Return", command = self.xcom))
+                    self.screen_elements[i].grid(row=rs,column=i,sticky=(N,S,E,W))
+                case "u":
+                    self.screen_elements.append(Button(self, text="Continue", command = lambda: self.ycom(ycommand)))
+                    self.screen_elements[i].grid(row=rs,column=i,sticky=(N,S,E,W))
+                case "b":
+                    self.screen_elements.append(Button(self, text="Back", command = self.xcom))
+                    self.screen_elements[i].grid(row=rs,column=i,sticky=(N,S,E,W))
+                case "x":
+                    self.screen_elements.append(Button(self, text="Close", command = self.xcom))
+                    self.screen_elements[i].grid(row=rs,column=i,sticky=(N,S,E,W))
+                case "c":
+                    self.screen_elements.append(Button(self, text="Confirm", command = lambda: self.ycom(ycommand)))
+                    self.screen_elements[i].grid(row=rs,column=i,sticky=(N,S,E,W))
+                case "d":
+                    self.screen_elements.append(ttk.Combobox(self, values=droplist))
+                    self.screen_elements[i].grid(row=rs,column=i,sticky=(N,S,E,W))
+                case _:
+                    pass
+
+
+        #Ensure visibility
+        self.focus_force()
+        
+        #SubWindow Geometry
+        self.update()
+        self.WindowGeometry.getGeometry(True)
+        self.WindowGeometry.setGeometry(width=self.winfo_width(),
+                                        height=self.winfo_height(),
+                                        align="center",
+                                        size_style="window_relative",
+                                        window_ref=parent)
+
+    def ycom(self,command):
+        self.destroy()
+        if not command is None:
+            command()
+
+    def xcom(self):
+        self.destroy()

VIStk/Widgets/_VISMenu.py

@@ -0,0 +1,51 @@
+import json
+from tkinter import *
+from tkinter import ttk
+from VIStk.Widgets import MenuItem
+
+class VISMenu():
+    """The menu class drawings a column of buttons with subprocess calls to paths defined in a corresponding .json file.
+
+    Has two roots because can destory both main window and subwindow on redirect.
+    """
+    def __init__(self, parent:Frame|LabelFrame|Toplevel|Tk, path:str):
+        """
+        Args:
+            root (Tk): Master root for destruction on redirect
+            _root (Toplevel): Toplevel object to create menu on
+            path (str): Path to .json file describing menu
+            destroyOnRedirect (bool): If True the root window will be destroyed on redicet
+        """
+
+        self.parent = parent
+        self.root = self.parent.winfo_toplevel()
+        self.path = path
+        self.ob_dict = []
+        self.n_dict = {}
+
+        #Open json file for menu structure
+        with open(path) as file:
+            self.dict:dict = json.load(file)
+        self.parent.grid_columnconfigure(0,weight=1)
+        for i in range(0, len(self.dict.keys()), 1):
+            self.parent.grid_rowconfigure(i,weight=1)
+
+        x = 0
+        for item in self.dict:
+            ob = MenuItem(self.parent,
+                      path= self.dict[item]["path"],
+                      nav = self.dict[item]["nav"],
+                      text = self.dict[item]["text"],
+                      relief="flat"
+                      )
+            ob.button.grid(row=x, column=0, sticky=(N,S,E,W))
+            self.ob_dict.append(ob)
+            self.n_dict[ob.nav]=ob
+            x += 1
+
+        self.root.bind("<KeyPress>",self.menuNav)
+    
+    def menuNav(self,happ:Event):
+        k=happ.char
+        if self.n_dict.get(k) != None:
+            self.n_dict[k].itemPath()

VIStk/Widgets/_WarningWindow.py

@@ -0,0 +1,8 @@
+from VIStk.Widgets._QuestionWindow import QuestionWindow
+from tkinter import *
+
+class WarningWindow(QuestionWindow):
+    def __init__(self, warning:str|list[str], parent:Toplevel|Tk, *args, **kwargs):
+        super().__init__(question=warning, parent=parent, answer="u", ycommand=None, *args, **kwargs)
+        self.screen_elements[0]["anchor"] = "center"
+        self.modalize()

VIStk/Widgets/__init__.py

@@ -0,0 +1,7 @@
+from VIStk.Widgets._MenuItem import MenuItem
+from VIStk.Widgets._VISMenu import Menu
+from VIStk.Widgets._QuestionWindow import QuestionWindow
+from VIStk.Widgets._MenuWindow import MenuWindow
+from VIStk.Widgets._WarningWindow import WarningWindow
+
+__all__ = ["Menu","MenuItem","MenuWindow","QuestionWindow","WarningWindow"]

VIStk/fUtil.py

@@ -0,0 +1,90 @@
+from tkinter import *
+from tkinter.font import Font as tkfont
+import sys
+
+global cfp
+if str.upper(sys.platform)=="WIN32":
+    cfp = 'win'
+else:
+    cfp = 'rasp'
+
+class fUtil():
+    def __init__(self):
+        if cfp == 'win':
+            self.defont = "Arial"
+        else: #Liberation Sans is the Linux Available version of Arial
+            self.defont = "LiberationSans"
+
+    def mkfont(size:int,bold:bool=False,font:str="default"):
+        """Creates a font string with wom fonts"""
+
+        if font == "default":
+            return f"{fUtil().defont} {size}{' bold' if bold is True else ''}"
+        
+    def autosize(e:Event=None, relations:list[Widget]=None, offset:int=None,shrink:int=0):
+        """Automatically sizes text given a widget with text."""
+        if not e is None: #Always need an event
+            #Get info from widget
+            widget:Widget = e.widget
+            w = widget.winfo_width() - 1 - shrink
+            h = widget.winfo_height() - 1
+            if w < 1 or h < 1:
+                return None
+            _root=widget.winfo_toplevel()
+            ffont = tkfont(_root, widget["font"])
+            fw = ffont.measure(widget["text"])
+            fh = ffont.metrics('linespace')
+
+            #Check widget with tightest relation
+            if not relations is None:
+                tempwi = widget
+                for wi in relations:
+                    if isinstance(wi["text"],str):
+                        if wi.winfo_width() > 1:
+                            test = (wi.winfo_width() - 1 - ffont.measure(wi["text"]) < w-fw)
+                        else:
+                            test = False
+                    else: test = False
+                    if test:
+                        widget = wi
+                    else:
+                        if wi.winfo_height() - 1 < h:#text has same height so only widget height must be smaller
+                            if wi.winfo_height() > 1:
+                                widget = wi
+                    w = widget.winfo_width() - 1 - shrink
+                    h = widget.winfo_height() - 1
+                    fw = ffont.measure(widget["text"])
+                relations.append(tempwi)
+
+            #Final Control Sizes
+            _family = ffont.actual(option="family").replace(" ", "")
+            _size = ffont.actual(option="size")
+            _weight = ffont.actual(option="weight")
+
+            while True: #Make text larger than frame
+                if fw < w and fh < h:
+                    _size = _size + 1
+                else:
+                    break
+                ffont = tkfont(widget.winfo_toplevel(), f"{_family} {_size} {_weight}")
+                fh = ffont.metrics('linespace')
+                fw = ffont.measure(widget["text"])
+
+            while True: #Make text fit in frame
+                if fw <= w and fh <= h:
+                    break
+                else:
+                    if _size == 0:break
+                    _size = _size - 1
+                ffont = tkfont(_root, f"{_family} {_size} {_weight}")
+                fh = ffont.metrics('linespace')
+                fw = ffont.measure(widget["text"])
+
+            if not offset is None: #Apply offset
+                _size = _size - offset
+
+            if not relations is None: #Correct relations
+                for wi in relations:
+                    wi.configure(font = f"{_family} {_size} {_weight}")
+            else:
+                widget.configure(font = f"{_family} {_size} {_weight}")