pytribeam 0.0.1__py3-none-any.whl

pytribeam/GUI/CustomTkinterWidgets/__init__.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+"""
+Code taken from https://github.com/Aboghazala/AwesomeTkinter/
+"""
+
+import tkinter as tk
+from tkinter import ttk
+
+from .button import Button, Button3d, Radiobutton, Checkbutton
+from .frame import Frame3d, ScrollableFrame, ToggledFrame, ExpandableFrame
+from .menu import RightClickMenu
+from .progressbar import RadialProgressbar, RadialProgressbar3d, Segmentbar, Progressbar
+from .scrollbar import SimpleScrollbar
+from .text import ScrolledText
+from .utils import *
+from .config import *
+from .theme import *
+from .tooltip import tooltip
+from .listbox import Listbox, DragDropListbox
+from .menubutton import MenuButton, EntryMenuButton
+from .entry import Entry, PathEntry
+from .label import AutofitLabel, AutoWrappingLabel
+from .dialog import filechooser, folderchooser
+from .datepicker import DatePicker
+
+
+def main():
+    print("Hello from CustomTkinterWidgets!")

pytribeam/GUI/CustomTkinterWidgets/button.py

@@ -0,0 +1,312 @@
+"""
+Code taken from https://github.com/Aboghazala/AwesomeTkinter/
+"""
+
+import tkinter as tk
+from tkinter import ttk
+from .utils import *
+from .config import *
+from .images import *
+
+
+class Button(tk.Button):
+    """A tk  MenuButton."""
+
+    def __init__(
+        self, parent, text, h_bg=None, h_fg=None, bg=None, fg=None, command=None, **kw
+    ):
+        """Initialize the menubutton."""
+
+        self.bg = bg or get_widget_attribute(parent, "background")
+        self.fg = fg or calc_font_color(self.bg)
+        h_bg = h_bg or bg
+        h_fg = h_fg or fg
+        a_fg = h_fg or fg
+        a_bg = h_bg or bg
+        kw.update(
+            dict(
+                text=text,
+                bg=self.bg,
+                fg=self.fg,
+                highlightcolor=h_bg,
+                activebackground=a_bg,
+                activeforeground=a_fg,
+                command=command,
+            )
+        )
+        tk.Button.__init__(self, parent, **kw)
+        self.bind("<Enter>", self.on_enter)
+        self.bind("<Leave>", self.on_leave)
+
+    def on_enter(self, e):
+        self.config(bg=self["activebackground"], fg=self["activeforeground"])
+
+    def on_leave(self, e):
+        self.config(bg=self.bg, fg=self.fg)
+
+
+class Button3d(ttk.Button):
+    """create a button with 3d background color and shadow"""
+
+    styles = []
+
+    def __init__(self, parent, bg=None, fg=None, **options):
+        """initialize
+
+        Args:
+            parent: tkinter container widget, i.e. root or another frame
+            bg (str): button color
+            fg (str): text color
+        """
+        self.bg = bg or DEFAULT_COLOR
+        parent_color = get_widget_attribute(parent, "background") or DEFAULT_COLOR
+
+        # initialize super class
+        ttk.Button.__init__(self, parent, **options)
+
+        # create unique style name based on frame color
+        button_style = f"Button3d_{len(Button3d.styles)}_.TButton"
+
+        # create style
+        if button_style not in Button3d.styles:
+            self.create_images()
+
+            # create elements
+            s = ttk.Style()
+            element_name = f"Button.focus.{button_style}_element"
+            s.element_create(
+                element_name,
+                "image",
+                self.img,
+                ("pressed", self.pressed_img),
+                border=12,
+                sticky="nsew",
+            )
+
+            s.layout(
+                button_style,
+                [
+                    (
+                        element_name,
+                        {
+                            "sticky": "nswe",
+                            "children": [
+                                (
+                                    "Button.padding",
+                                    {
+                                        "sticky": "nswe",
+                                        "children": [
+                                            ("Button.label", {"sticky": "nswe"})
+                                        ],
+                                    },
+                                )
+                            ],
+                        },
+                    )
+                ],
+            )
+
+            s.map(
+                button_style,
+                background=[("", parent_color)],
+                foreground=[("", calc_font_color(self.bg))],
+            )
+            s.configure(button_style, padding=0, borderwidth=0, focuscolor=self.bg)
+            s.configure(button_style, font=FONT)
+
+            # add to styles
+            Button3d.styles.append(button_style)
+
+        self["style"] = button_style
+
+    def create_images(self):
+
+        shadow_img = create_pil_image(b64=btn_base)
+        img = create_pil_image(b64=btn_face, color=self.bg)
+
+        # merge face with base image
+        img = mix_images(shadow_img, img)
+
+        pressed_img = img.rotate(180)
+
+        self.img = ImageTk.PhotoImage(img)
+        self.pressed_img = ImageTk.PhotoImage(pressed_img)
+
+
+class Radiobutton(ttk.Radiobutton):
+    """ttk.Radiobutton with better indicator quality"""
+
+    styles = []
+    imgs = {"outline_img": {}, "selection_img": {}}
+
+    def __init__(
+        self,
+        parent,
+        text=None,
+        ind_bg=None,
+        ind_mark_color=None,
+        ind_outline_color=None,
+        bg=None,
+        fg=None,
+        font=None,
+        value=None,
+        **kwargs,
+    ):
+        """initialize
+        Args:
+            parent: tkinter container
+            text (str): text
+            ind_bg (str): indicator ring background "fill color"
+            ind_outline_color (str): indicator outline / ring color
+            ind_mark_color (str): check mark color
+            bg (str): background color "should match parent bg
+            fg (str): text color
+            font (str): text font, e.g. "any 10 bold"
+            value (any): value assigned to button variable when selected
+        """
+        bg = bg or get_widget_attribute(parent, "background")
+        fg = fg or calc_font_color(bg)
+        ind_bg = ind_bg or bg
+        ind_outline_color = ind_outline_color or fg
+        ind_mark_color = ind_mark_color or fg
+
+        value = value if value is not None else text
+
+        custom_style = f"RadioButton_{len(Radiobutton.styles)}"
+        Radiobutton.styles.append(custom_style)
+
+        s = ttk.Style()
+
+        self.outline_img = Radiobutton.imgs["outline_img"].get(ind_outline_color)
+        self.selection_img = Radiobutton.imgs["selection_img"].get(ind_mark_color)
+
+        # create tkinter PhotoImage
+        if not (self.outline_img and self.selection_img):
+            # create indicator outline
+            outline_img = create_circle(
+                size=12, thickness=1, color=ind_outline_color, fill=ind_bg, offset=2
+            )
+
+            # create indicator mark
+            mark_img = create_circle(
+                size=6, thickness=0, color=ind_mark_color, fill=ind_mark_color
+            )
+
+            selection_img = mix_images(outline_img, mark_img)
+
+            # create tkinter PhotoImage
+            self.outline_img = create_image(img=outline_img)
+            self.selection_img = create_image(img=selection_img)
+
+            # store them for future use
+            Radiobutton.imgs["outline_img"][ind_outline_color] = self.outline_img
+            Radiobutton.imgs["selection_img"][ind_mark_color] = self.selection_img
+
+        # custom style
+        s.layout(
+            custom_style,
+            [
+                (
+                    "Radiobutton.padding",
+                    {
+                        "sticky": "nswe",
+                        "children": [("Radiobutton.label", {"sticky": "nswe"})],
+                    },
+                )
+            ],
+        )
+        s.configure(custom_style, foreground=fg)
+        s.map(custom_style, background=[("", bg)])
+
+        if font:
+            s.configure(custom_style, font=font)
+
+        # set default options
+        options = dict(
+            text=text,
+            value=value,
+            style=custom_style,
+            image=[self.outline_img, "selected", self.selection_img],
+            compound="left",
+        )
+
+        # override default options
+        options.update(**kwargs)
+
+        # initialize super class
+        ttk.Radiobutton.__init__(self, master=parent, **options)
+
+
+class Checkbutton(tk.Checkbutton):
+    """tk.checkbutton with images"""
+
+    imgs = {"empty_box_img": {}, "checked_box_img": {}}
+
+    def __init__(
+        self,
+        parent,
+        box_color=None,
+        check_mark_color=None,
+        text_color=None,
+        size=None,
+        **kwargs,
+    ):
+        """initialize
+        Args:
+            parent: tkinter container
+            box_color (str): checkbox outline color
+            check_mark_color (str): check mark color
+        """
+        bg = kwargs.get("bg") or get_widget_attribute(
+            parent, "background"
+        )  # bg of checkbox
+        check_mark_color = check_mark_color or calc_font_color(bg)
+        box_color = box_color or calc_font_color(bg)
+        text_color = text_color or calc_font_color(bg)
+
+        # images
+        self.empty_box_img = Checkbutton.imgs["empty_box_img"].get(box_color)
+        self.checked_box_img = Checkbutton.imgs["checked_box_img"].get(check_mark_color)
+
+        # create tkinter PhotoImage
+        if not (self.empty_box_img and self.checked_box_img):
+            self.empty_box_img = create_image(
+                b64=unchecked_icon, color=box_color, size=size
+            )
+            self.checked_box_img = create_image(
+                b64=checked_icon, color=check_mark_color, size=size
+            )
+
+            # store images for future use
+            Checkbutton.imgs["empty_box_img"][box_color] = self.empty_box_img
+            Checkbutton.imgs["checked_box_img"][check_mark_color] = self.checked_box_img
+
+        # set default options
+        options = dict(
+            bg=bg,
+            activebackground=bg,
+            highlightbackground=bg,
+            fg=text_color,
+            activeforeground=text_color,
+            selectcolor=bg,
+            compound="left",
+            indicatoron=False,  # disable original indicator
+            image=self.empty_box_img,
+            selectimage=self.checked_box_img,
+        )
+
+        # add space before text
+        text = kwargs.get("text")
+        if text:
+            kwargs["text"] = " " + text
+
+        # override default options
+        options.update(**kwargs)
+        if "dtype" in kwargs:
+            options.pop("dtype")
+
+        # initialize super class
+        tk.Checkbutton.__init__(self, master=parent, **options)
+
+
+__all__ = ["Button", "Button3d", "Radiobutton", "Checkbutton"]

pytribeam/GUI/CustomTkinterWidgets/config.py

@@ -0,0 +1,20 @@
+# DEFAULT_COLOR = '#333'
+# ACCENT_COLOR1 = '#00baff'
+# ACCENT_COLOR2 = '#ff00ff'
+DEFAULT_COLOR = "#eeeeee"
+ACCENT_COLOR1 = "#e7e614"
+ACCENT_COLOR2 = "#92278f"
+ACCENT_COLOR3 = "#ed1c24"
+GREEN = "#2d9546"
+RED = "#ed1c24"
+YELLOW = "#f7e615"
+BLACK = "#000"
+TERMINAL_COLOR = "#333"
+
+HEADER_FONT = ("Segoe UI", 15, "bold")
+SUBHEADER_FONT = ("Segoe UI", 13, "bold")
+FONT = ("Segoe UI", 11)
+FONT_BOLD = ("Segoe UI", 11, "bold")
+FONT_ITALIC = ("Segoe UI", 11, "italic")
+MENU_FONT = ("Segoe UI", 9)
+TIP_FONT = ("Segoe UI", 9)

pytribeam/GUI/CustomTkinterWidgets/datepicker.py

@@ -0,0 +1,209 @@
+"""
+Code taken from https://github.com/Aboghazala/AwesomeTkinter/
+"""
+
+import datetime
+import tkinter as tk
+from tkinter import ttk
+
+from .utils import *
+
+
+class DatePicker(tk.Toplevel):
+    """Date picker window"""
+
+    def __init__(
+        self,
+        master,
+        min_year=None,
+        max_year=None,
+        year=None,
+        month=None,
+        day=None,
+        hour=None,
+        minute=None,
+        title="Date Picker",
+        bg=None,
+        fg=None,
+        sbg=None,
+        btnbg=None,
+        btnfg=None,
+        width=420,
+        height=180,
+    ):
+        """initialize
+
+        Args:
+            parent: parent window
+            min_year (int): minimum year to show
+            max_year (int): max. year to show
+            year, month, day, hour, minute (int): set selected time
+            title (str): window title
+        """
+        self.master = master
+        master_bg = get_widget_attribute(master, "background")
+        self.bg = bg or calc_contrast_color(master_bg, 30)
+        self.fg = fg or calc_font_color(self.bg)
+        self.sbg = sbg or fg
+        self.btnbg = btnbg or self.sbg
+        self.btnfg = btnfg or calc_font_color(self.btnbg)
+
+        today = datetime.datetime.today()
+        year = year or today.year
+        min_year = min_year or year - 100
+        max_year = max_year or year + 100
+        month = month or today.month
+        day = day or today.day
+        hour = hour or today.hour
+        minute = minute or today.minute
+
+        self.selected_date = None
+
+        self.fields = {
+            "Year": {"values": list(range(min_year, max_year + 1)), "selection": year},
+            "Month": {"values": list(range(1, 13)), "selection": month},
+            "Day": {"values": list(range(1, 32)), "selection": day},
+            "Hour": {"values": list(range(0, 24)), "selection": hour},
+            "Minute": {"values": list(range(0, 60)), "selection": minute},
+        }
+
+        # initialize super
+        tk.Toplevel.__init__(self, self.master)
+
+        # bind window close
+        center_window(self, width=width, height=height, reference=self.master)
+
+        self.title(title)
+        self.config(bg=self.sbg)
+
+        self.create_widgets()
+
+        self.wait_window(self)
+
+    def is_leap(self, year):
+        """year -> 1 if leap year, else 0, source: datetime.py"""
+        return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
+
+    def days_in_month(self, year, month):
+        """year, month -> number of days in that month in that year, modified from source: datetime.py"""
+        default = [-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
+        if month == 2 and self.is_leap(year):
+            return 29
+        return default[month]
+
+    def create_widgets(self):
+        bg = self.bg
+        fg = self.fg
+        sbg = self.sbg
+        btnbg = self.btnbg
+        btnfg = self.btnfg
+        main_frame = tk.Frame(self, bg=bg)
+        top_frame = tk.Frame(main_frame, bg=bg)
+        tk.Label(top_frame, text="Select Date and time:", bg=bg, fg=fg).pack(
+            side="left", padx=5, pady=5
+        )
+
+        middle_frame = tk.Frame(main_frame, bg=bg)
+
+        def set_field(field_name, value):
+            x = self.fields[field_name]
+            x["selection"] = int(value)
+
+            # set correct days according to month and year
+            year = self.fields["Year"]["selection"]
+            month = self.fields["Month"]["selection"]
+            day = self.fields["Day"]["selection"]
+            days_in_month = self.days_in_month(year, month)
+            day_combo.config(values=list(range(1, days_in_month + 1)))
+            if day > days_in_month:
+                corrected_value = days_in_month
+                day_combo.set(corrected_value)
+                self.fields["Day"]["selection"] = corrected_value
+
+        # style
+        s = ttk.Style()
+        custom_style = "custom.TCombobox"
+        # combobox consists of a text area, down arrow, and dropdown menu (listbox)
+        # arrow: arrowcolor, background
+        # text area: foreground, fieldbackground
+        arrow_bg = sbg
+        textarea_bg = btnbg
+        s.configure(
+            custom_style,
+            arrowcolor=calc_font_color(arrow_bg),
+            foreground=calc_font_color(textarea_bg),
+            padding=4,
+            relief=tk.RAISED,
+        )
+        s.map(
+            custom_style,
+            fieldbackground=[("", textarea_bg)],
+            background=[("", arrow_bg)],
+        )
+
+        def on_selection(event):
+            widget = event.widget
+            widget.selection_clear()
+
+            widget.callback()
+
+        c = 0
+        for key, item in self.fields.items():
+            tk.Label(middle_frame, text=key, bg=bg, fg=fg).grid(
+                row=0, column=c, padx=5, sticky="w"
+            )
+            cb = ttk.Combobox(
+                middle_frame,
+                state="readonly",
+                values=item["values"],
+                style=custom_style,
+                width=5,
+            )
+            cb.set(item["selection"])
+            cb.grid(row=1, column=c, padx=(5, 10), sticky="w")
+            cb.callback = lambda field_name=key, combo=cb: set_field(
+                field_name, combo.get()
+            )
+            cb.bind("<<ComboboxSelected>>", on_selection)
+
+            # get day combo box reference
+            if key == "Day":
+                day_combo = cb
+
+            c += 1
+
+        bottom_frame = tk.Frame(main_frame, bg=bg)
+        tk.Button(
+            bottom_frame, text="Cancel", command=self.close, bg=btnbg, fg=btnfg
+        ).pack(side="right", padx=5)
+        tk.Button(
+            bottom_frame, text="Ok", command=self.set_selection, bg=btnbg, fg=btnfg
+        ).pack(side="right")
+
+        main_frame.pack(expand=True, fill="both", padx=(10, 0), pady=(10, 0))
+        bottom_frame.pack(side="bottom", fill="x", pady=5)
+        ttk.Separator(main_frame).pack(side="bottom", fill="x", expand=True)
+        middle_frame.pack(side="bottom", expand=True, fill="both")
+        ttk.Separator(main_frame).pack(side="bottom", fill="x", expand=True)
+        top_frame.pack(side="bottom", fill="x")
+
+    def close(self):
+        self.destroy()
+
+    def set_selection(self):
+        """return selected date"""
+        values = [int(item["selection"]) for item in self.fields.values()]
+        self.selected_date = datetime.datetime(*values)
+        self.close()
+
+
+if __name__ == "__main__":
+    root = tk.Tk()
+
+    def foo():
+        dp = DatePicker(root, year=1900, day=23, hour=18, bg="white", fg="black")
+        print(dp.selected_date)
+
+    tk.Button(root, text="select date", command=foo).pack()
+    root.mainloop()

pytribeam/GUI/CustomTkinterWidgets/dialog.py

@@ -0,0 +1,108 @@
+"""
+Code taken from https://github.com/Aboghazala/AwesomeTkinter/
+"""
+
+import platform
+import subprocess
+import shlex
+from tkinter import filedialog
+
+
+operating_system = (
+    platform.system()
+)  # current operating system  ('Windows', 'Linux', 'Darwin')
+
+
+def run_command(cmd):
+    try:
+        p = subprocess.run(shlex.split(cmd), stdout=subprocess.PIPE, check=True)
+        return p.returncode, p.stdout.decode("utf-8").strip()
+    except Exception as e:
+        # print(e)
+        return -1, ""
+
+
+class FileDialog:
+    """use alternative file chooser to replace tkinter ugly file chooser on linux
+
+    available options:
+        Zenity: command line tool, based on gtk
+        kdialog: command line tool for kde file chooser
+        gtk: use Gtk.FileChooserDialog directly thru python, "Don't not use", since sometimes it will raise
+             error: Gdk-Message: Fatal IO error 0 (Success) on X server :1, and application will crash
+    """
+
+    def __init__(self, foldersonly=False):
+        self.use = "TK"  # , 'zenity', or 'kdialog'
+        self.foldersonly = foldersonly
+        self.title = "FireDM - "
+        self.title += "Select a folder" if self.foldersonly else "Select a file"
+        if operating_system == "Linux":
+            # looking for zenity
+            _, zenity_path = run_command("which zenity")
+            if zenity_path:
+                self.use = "zenity"
+            else:
+                # looking for kdialog
+                _, kdialog_path = run_command("which kdialog")
+                if kdialog_path:
+                    self.use = "kdialog"
+
+    def run(self, initialdir="", backend=None):
+        selected_path = initialdir
+        if backend:
+            self.use = backend
+
+        if self.use == "zenity":
+            cmd = "zenity --file-selection"
+            if self.foldersonly:
+                cmd += " --directory"
+            if isinstance(initialdir, str):
+                cmd += f' --filename="{initialdir}"'
+            retcode, path = run_command(cmd)
+            # zenity will return either 0, 1 or 5, depending on whether the user pressed OK,
+            # Cancel or timeout has been reached
+            if retcode in (0, 1, 5):
+                selected_path = path
+
+        elif self.use == "kdialog":
+            cmd = "kdialog"
+            if self.foldersonly:
+                cmd += " --getexistingdirectory"
+            else:
+                cmd += " --getopenfilename"
+
+            if isinstance(initialdir, str):
+                cmd += f' "{initialdir}"'
+
+            retcode, path = run_command(cmd)
+            # kdialog will return either 0, 1 depending on whether the user pressed OK, Cancel
+            if retcode in (0, 1):
+                selected_path = path
+        else:
+            selected_path = self.run_default(initialdir=initialdir)
+
+        return selected_path
+
+    def run_default(self, initialdir=""):
+        # use ugly tkinter filechooser
+        if self.foldersonly:
+            selected_path = filedialog.askdirectory(initialdir=initialdir)
+        else:
+            selected_path = filedialog.askopenfilename(initialdir=initialdir)
+
+        return selected_path
+
+
+filechooser = FileDialog().run
+folderchooser = FileDialog(foldersonly=True).run
+
+
+if __name__ == "__main__":
+    # ret, stdout = run_command('blah blah')
+    # print(ret, stdout)
+    test_fp = filechooser(backend="kdialog")
+    print(test_fp)
+    #
+    test_dir = folderchooser()
+    print(test_dir)