Python XML 3

import tkinter as tk

from tkinter import ttk, messagebox, filedialog

import xml.etree.ElementTree as ET

import os

def load_xml_data(file_path):

    """Load and parse XML file, returning headers and rows."""

    try:

        tree = ET.parse(file_path)

        root = tree.getroot()

        # Assume each child of root is a row, and its sub-elements are columns

        rows = []

        headers = set()

        for row_elem in root:

            row_data = {}

            for col_elem in row_elem:

                headers.add(col_elem.tag)

                row_data[col_elem.tag] = col_elem.text or ""

            rows.append(row_data)

        headers = sorted(headers)  # Keep consistent order

        return headers, rows

    except ET.ParseError:

        messagebox.showerror("XML Error", "Invalid XML format.")

        return [], []

    except FileNotFoundError:

        messagebox.showerror("File Error", "File not found.")

        return [], []

    except Exception as e:

        messagebox.showerror("Error", str(e))

        return [], []

def display_table(headers, rows):

    """Display data in a Tkinter Treeview table."""

    # Clear old table if exists

    for widget in table_frame.winfo_children():

        widget.destroy()

    if not headers or not rows:

        tk.Label(table_frame, text="No data to display").pack()

        return

    # Create Treeview

    tree = ttk.Treeview(table_frame, columns=headers, show="headings")

    tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

    # Add column headings

    for header in headers:

        tree.heading(header, text=header)

        tree.column(header, width=120, anchor="center")

    # Insert rows

    for row in rows:

        tree.insert("", tk.END, values=[row.get(h, "") for h in headers])

    # Add scrollbar

    scrollbar = ttk.Scrollbar(table_frame, orient="vertical", command=tree.yview)

    tree.configure(yscroll=scrollbar.set)

    scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

def open_file():

    """Open file dialog and load XML data."""

    file_path = filedialog.askopenfilename(

        title="Select XML File",

        filetypes=[("XML Files", "*.xml"), ("All Files", "*.*")]

    )

    if file_path:

        headers, rows = load_xml_data(file_path)

        display_table(headers, rows)

# --- Tkinter GUI Setup ---

root = tk.Tk()

root.title("XML Data Table Viewer")

root.geometry("700x400")

# Menu

menu_bar = tk.Menu(root)

file_menu = tk.Menu(menu_bar, tearoff=0)

file_menu.add_command(label="Open XML", command=open_file)

file_menu.add_separator()

file_menu.add_command(label="Exit", command=root.quit)

menu_bar.add_cascade(label="File", menu=file_menu)

root.config(menu=menu_bar)

# Table Frame

table_frame = tk.Frame(root)

table_frame.pack(fill=tk.BOTH, expand=True)

# Start GUI

root.mainloop()

 

Python XML 2

 

import tkinter as tk

from tkinter import ttk

import xml.etree.ElementTree as ET

# Fungsi untuk memuat dan mencari data dari XML

def search_data():

    query = search_entry.get().lower()

    

    # Hapus data lama di tabel sebelum menampilkan hasil baru

    for row in tree.get_children():

        tree.delete(row)

        

    try:

        # Load file XML (Ganti 'data.xml' dengan nama file Anda)

        tree_xml = ET.parse('data2.xml')

        root = tree_xml.getroot()

        

        for item in root.findall('item'):

            # Ambil data dari tag XML (sesuaikan nama tag dengan file Anda)

            name = item.find('name').text

            category = item.find('category').text

            price = item.find('price').text

            

            # Filter berdasarkan input pencarian

            if query in name.lower() or query in category.lower():

                tree.insert("", "end", values=(name, category, price))

                

    except FileNotFoundError:

        print("Error: File 'data.xml' tidak ditemukan.")

# --- Setup GUI ---

root = tk.Tk()

root.title("Pencarian Data XML")

root.geometry("600x400")

# 1. Kotak Input Pencarian

search_frame = tk.Frame(root)

search_frame.pack(pady=10)

tk.Label(search_frame, text="Cari:").pack(side=tk.LEFT, padx=5)

search_entry = tk.Entry(search_frame, width=30)

search_entry.pack(side=tk.LEFT, padx=5)

# Tombol Search

search_btn = tk.Button(search_frame, text="Cari", command=search_data)

search_btn.pack(side=tk.LEFT)

# 2. Tabel Data (Treeview)

columns = ("Name", "Category", "Price")

tree = ttk.Treeview(root, columns=columns, show="headings")

# Definisi Header Tabel

for col in columns:

    tree.heading(col, text=col)

    tree.column(col, width=150)

tree.pack(padx=10, pady=10, fill=tk.BOTH, expand=True)

# Jalankan fungsi pencarian pertama kali untuk memuat semua data

search_data()

root.mainloop()

==============================

data2.xml

<?xml version="1.0"?>

<root>

    <item>

        <name>Laptop</name>

        <category>Electronics</category>

        <price>1200</price>

    </item>

    <item>

        <name>Mouse</name>

        <category>Electronics</category>

        <price>100</price>

    </item>

    <item>

        <name>Speaker</name>

        <category>Electronics</category>

        <price>120</price>

    </item>

     <item>

        <name>Flasdisk</name>

        <category>Electronics</category>

        <price>10</price>

    </item>

    <item>

        <name>Keyboard</name>

        <category>Electronics</category>

        <price>120</price>

    </item>

</root>

Python XML 1

 

import tkinter as tk

from tkinter import ttk, messagebox

import xml.etree.ElementTree as ET

import os

# ---------------------------

# Load XML Data Function

# ---------------------------

def load_xml_data(file_path):

    """Load and parse XML data into a list of dictionaries."""

    if not os.path.exists(file_path):

        messagebox.showerror("Error", f"File not found: {file_path}")

        return []

    try:

        tree = ET.parse(file_path)

        root = tree.getroot()

        data_list = []

        for item in root.findall("record"):

            record_data = {

                "ID": item.findtext("id", "").strip(),

                "Name": item.findtext("name", "").strip(),

                "Age": item.findtext("age", "").strip(),

                "City": item.findtext("city", "").strip()

            }

            data_list.append(record_data)

        return data_list

    except ET.ParseError as e:

        messagebox.showerror("XML Parse Error", str(e))

        return []

# ---------------------------

# Search Function

# ---------------------------

def search_data():

    """Filter table based on search query."""

    query = search_var.get().lower().strip()

    table.delete(*table.get_children())  # Clear table

    for row in xml_data:

        if query in row["Name"].lower() or query in row["City"].lower():

            table.insert("", tk.END, values=(row["ID"], row["Name"], row["Age"], row["City"]))

# ---------------------------

# Main Tkinter Window

# ---------------------------

root = tk.Tk()

root.title("XML Search & Display")

root.geometry("600x400")

# Search Input

search_var = tk.StringVar()

tk.Label(root, text="Search:").pack(pady=5)

search_entry = tk.Entry(root, textvariable=search_var, width=40)

search_entry.pack(pady=5)

tk.Button(root, text="Search", command=search_data).pack(pady=5)

# Table (Treeview)

columns = ("ID", "Name", "Age", "City")

table = ttk.Treeview(root, columns=columns, show="headings")

for col in columns:

    table.heading(col, text=col)

    table.column(col, width=100)

table.pack(fill=tk.BOTH, expand=True, pady=10)

# Load XML Data

xml_file = "data.xml"  # Change to your XML file path

xml_data = load_xml_data(xml_file)

# Display all data initially

for row in xml_data:

    table.insert("", tk.END, values=(row["ID"], row["Name"], row["Age"], row["City"]))

root.mainloop()

=========================

data.xml

<?xml version="1.0"?>

<records>

    <record>

        <id>1</id>

        <name>John Doe</name>

        <age>30</age>

        <city>New York</city>

    </record>

    <record>

        <id>2</id>

        <name>Jane Smith</name>

        <age>25</age>

        <city>Los Angeles</city>

    </record>

    <record>

        <id>3</id>

        <name>Michael Brown</name>

        <age>40</age>

        <city>Chicago</city>

    </record>

</records>

Python Menu 3

 

import tkinter as tk

class App:

    def __init__(self, root):

        self.root = root

        self.root.geometry("600x400")

        

        # Menu toggle button

        self.btn_toggle = tk.Button(root, text="☰ Menu", command=self.toggle_menu)

        self.btn_toggle.place(x=10, y=10)

        # Sliding frame

        self.menu_frame = tk.Frame(root, bg="#333333", width=0, height=400)

        self.menu_frame.pack_propagate(False) # Allows width to change

        

        # Menu Items

        self.menu_items = [f"Menu Item {i}" for i in range(1, 8)]

        for item in self.menu_items:

            tk.Button(self.menu_frame, text=item, bg="#333333", fg="white", 

                      font=("Arial", 12), relief="flat", anchor="w").pack(fill="x", pady=5, padx=10)

        self.menu_visible = False

    def toggle_menu(self):

        if not self.menu_visible:

            # Slide In

            for i in range(0, 201, 20): # Width 0 to 200

                self.menu_frame.place(x=0, y=50, width=i, height=350)

                self.root.update()

        else:

            # Slide Out

            for i in range(200, -1, -20): # Width 200 to 0

                self.menu_frame.place(x=0, y=50, width=i, height=350)

                self.root.update()

        self.menu_visible = not self.menu_visible

root = tk.Tk()

app = App(root)

root.mainloop()

Python Menu 2

 

import tkinter as tk

class SlidingMenuApp:

    def __init__(self, root):

        self.root = root

        self.root.title("Sliding Menu")

        self.root.geometry("400x600")

        # Menu configuration

        self.menu_width = 200

        self.menu_height = 400

        self.is_open = False

        

        # Calculate hidden starting position (below the window)

        self.hidden_y = 600

        self.visible_y = 200 # Height where it stops

        # --- Create Menu Frame ---

        self.menu_frame = tk.Frame(self.root, bg="#333333", width=self.menu_width, height=self.menu_height)

        self.menu_frame.place(x=-self.menu_width, y=self.hidden_y) # Initially hidden

        self.menu_frame.pack_propagate(False) # Maintain size

        # --- Menu Items ---

        menu_items = ["menuitem1", "menuitem2", "menuitem3", "menuitem4", 

                      "menuitem5", "menuitem6", "menuitem7"]

        for item in menu_items:

            btn = tk.Button(self.menu_frame, text=item, bg="#333333", fg="white", 

                            font=("Arial", 12), bd=0, anchor="w",

                            command=lambda i=item: print(f"{i} clicked"))

            btn.pack(fill="x", pady=10, padx=20)

        # --- Toggle Button ---

        self.toggle_btn = tk.Button(self.root, text="Menu", command=self.toggle_menu, 

                                     bg="white", font=("Arial", 12))

        self.toggle_btn.place(x=10, y=10)

    def toggle_menu(self):

        if not self.is_open:

            self.slide_in(self.hidden_y)

        else:

            self.slide_out(self.visible_y)

    def slide_in(self, y_pos):

        if y_pos > self.visible_y:

            y_pos -= 20 # Speed of slide

            self.menu_frame.place(x=0, y=y_pos)

            self.root.after(10, lambda: self.slide_in(y_pos))

        else:

            self.is_open = True

    def slide_out(self, y_pos):

        if y_pos < self.hidden_y:

            y_pos += 20 # Speed of slide

            self.menu_frame.place(x=0, y=y_pos)

            self.root.after(10, lambda: self.slide_out(y_pos))

        else:

            self.menu_frame.place(x=-self.menu_width, y=self.hidden_y)

            self.is_open = False

if __name__ == "__main__":

    root = tk.Tk()

    app = SlidingMenuApp(root)

    root.mainloop()

Python Menu

 

import tkinter as tk

from tkinter import messagebox

# -------------------------------

# Sliding Menu Application Class

# -------------------------------

class SlidingMenuApp:

    def __init__(self, root):

        self.root = root

        self.root.title("Sliding Menu Example")

        self.root.geometry("600x400")

        self.root.config(bg="white")

        # Menu state

        self.menu_width = 200

        self.menu_current_x = -self.menu_width

        self.menu_target_x = -self.menu_width

        self.menu_speed = 20  # pixels per frame

        # Create menu frame (hidden initially)

        self.menu_frame = tk.Frame(self.root, bg="#2c3e50", width=self.menu_width, height=400)

        self.menu_frame.place(x=self.menu_current_x, y=0)

        # Add menu items

        self.add_menu_items()

        # Create toggle button on the right side

        self.toggle_btn = tk.Button(

            self.root, text="☰", font=("Arial", 14, "bold"),

            bg="#3498db", fg="white", command=self.toggle_menu

        )

        self.toggle_btn.place(relx=1.0, x=-40, y=10, anchor="ne")

        # Start animation loop

        self.animate()

    def add_menu_items(self):

        """Add menu buttons."""

        menu_items = [

            ("Home", lambda: self.show_message("Home")),

            ("Information", lambda: self.show_message("Information")),

            ("Activities", lambda: self.show_message("Activities")),

            ("Feedback", lambda: self.show_message("Feedback")),

        ]

        for i, (text, cmd) in enumerate(menu_items):

            btn = tk.Button(

                self.menu_frame, text=text, font=("Arial", 12),

                bg="#34495e", fg="white", relief="flat", command=cmd

            )

            btn.place(x=10, y=20 + i * 50, width=self.menu_width - 20, height=40)

    def show_message(self, title):

        """Show a message box for menu item."""

        messagebox.showinfo("Menu Clicked", f"You clicked: {title}")

    def toggle_menu(self):

        """Toggle menu open/close."""

        if self.menu_target_x < 0:

            self.menu_target_x = 0  # open

        else:

            self.menu_target_x = -self.menu_width  # close

    def animate(self):

        """Smoothly animate menu sliding."""

        if self.menu_current_x < self.menu_target_x:

            self.menu_current_x += self.menu_speed

            if self.menu_current_x > self.menu_target_x:

                self.menu_current_x = self.menu_target_x

        elif self.menu_current_x > self.menu_target_x:

            self.menu_current_x -= self.menu_speed

            if self.menu_current_x < self.menu_target_x:

                self.menu_current_x = self.menu_target_x

        # Update menu position

        self.menu_frame.place(x=self.menu_current_x, y=0)

        # Repeat animation

        self.root.after(15, self.animate)

# -------------------------------

# Run the Application

# -------------------------------

if __name__ == "__main__":

    root = tk.Tk()

    app = SlidingMenuApp(root)

    root.mainloop()

Python Game - Submarine 8

 

import tkinter as tk

import math

import random

import time

# Game constants

CANVAS_WIDTH = 800

CANVAS_HEIGHT = 600

SUB_SPEED = 5

MISSILE_SPEED = 8

ENEMY_SPEED = 2

ENEMY_MISSILE_SPEED = 5

ROTATE_SPEED = 5  # degrees per frame

ENEMY_COUNT = 5

class Game:

    def __init__(self, root):

        self.root = root

        self.root.title("Submarine Battle")

        self.canvas = tk.Canvas(root, width=CANVAS_WIDTH, height=CANVAS_HEIGHT, bg="lightblue")

        self.canvas.pack()

        # Game state

        self.keys = set()

        self.submarine = {"x": 100, "y": CANVAS_HEIGHT//2, "angle": 0}

        self.sub_missiles = []

        self.enemies = []

        self.enemy_missiles = []

        self.propeller_angle = 0

        # Create enemies

        for _ in range(ENEMY_COUNT):

            self.enemies.append({

                "x": random.randint(CANVAS_WIDTH//2, CANVAS_WIDTH-50),

                "y": random.randint(50, CANVAS_HEIGHT-50),

                "angle": 0,

                "last_shot": time.time()

            })

        # Bind keys

        self.root.bind("<KeyPress>", self.key_down)

        self.root.bind("<KeyRelease>", self.key_up)

        self.root.bind("<space>", self.fire_missile)

        self.update_game()

    def key_down(self, event):

        self.keys.add(event.keysym.lower())

    def key_up(self, event):

        self.keys.discard(event.keysym.lower())

    def fire_missile(self, event):

        # Fire from submarine

        self.sub_missiles.append({"x": self.submarine["x"]+30, "y": self.submarine["y"], "dx": MISSILE_SPEED, "dy": 0})

    def fire_enemy_missile(self, enemy):

        dx = self.submarine["x"] - enemy["x"]

        dy = self.submarine["y"] - enemy["y"]

        dist = math.hypot(dx, dy)

        if dist == 0:

            return

        dx /= dist

        dy /= dist

        self.enemy_missiles.append({"x": enemy["x"]-30, "y": enemy["y"], "dx": dx*ENEMY_MISSILE_SPEED, "dy": dy*ENEMY_MISSILE_SPEED})

    def move_objects(self):

        # Move submarine

        if "w" in self.keys and self.submarine["y"] > 20:

            self.submarine["y"] -= SUB_SPEED

        if "s" in self.keys and self.submarine["y"] < CANVAS_HEIGHT-20:

            self.submarine["y"] += SUB_SPEED

        if "a" in self.keys and self.submarine["x"] > 20:

            self.submarine["x"] -= SUB_SPEED

        if "d" in self.keys and self.submarine["x"] < CANVAS_WIDTH-20:

            self.submarine["x"] += SUB_SPEED

        # Move missiles

        for m in self.sub_missiles:

            m["x"] += m["dx"]

            m["y"] += m["dy"]

        self.sub_missiles = [m for m in self.sub_missiles if 0 < m["x"] < CANVAS_WIDTH]

        for m in self.enemy_missiles:

            m["x"] += m["dx"]

            m["y"] += m["dy"]

        self.enemy_missiles = [m for m in self.enemy_missiles if 0 < m["x"] < CANVAS_WIDTH and 0 < m["y"] < CANVAS_HEIGHT]

        # Move enemies and shoot

        for enemy in self.enemies:

            if enemy["y"] < self.submarine["y"]:

                enemy["y"] += ENEMY_SPEED

            elif enemy["y"] > self.submarine["y"]:

                enemy["y"] -= ENEMY_SPEED

            # Shoot every 2 seconds

            if time.time() - enemy["last_shot"] > 2:

                self.fire_enemy_missile(enemy)

                enemy["last_shot"] = time.time()

    def draw_propeller(self, x, y, angle, size=10):

        for i in range(4):

            rad = math.radians(angle + i*90)

            x_end = x + size * math.cos(rad)

            y_end = y + size * math.sin(rad)

            self.canvas.create_line(x, y, x_end, y_end, fill="black", width=2)

    def draw_submarine(self):

        # Body

        self.canvas.create_oval(self.submarine["x"]-30, self.submarine["y"]-15,

                                self.submarine["x"]+30, self.submarine["y"]+15,

                                fill="yellow")

        # Propeller

        self.draw_propeller(self.submarine["x"]-35, self.submarine["y"], self.propeller_angle)

    def draw_enemy(self, enemy):

        self.canvas.create_oval(enemy["x"]-30, enemy["y"]-15,

                                enemy["x"]+30, enemy["y"]+15,

                                fill="red")

        self.draw_propeller(enemy["x"]+35, enemy["y"], self.propeller_angle)

    def draw_missiles(self):

        for m in self.sub_missiles:

            self.canvas.create_rectangle(m["x"]-3, m["y"]-2, m["x"]+3, m["y"]+2, fill="black")

        for m in self.enemy_missiles:

            self.canvas.create_rectangle(m["x"]-3, m["y"]-2, m["x"]+3, m["y"]+2, fill="purple")

    def update_game(self):

        self.canvas.delete("all")

        self.move_objects()

        # Rotate propellers

        self.propeller_angle = (self.propeller_angle + ROTATE_SPEED) % 360

        # Draw submarine

        self.draw_submarine()

        # Draw enemies

        for enemy in self.enemies:

            self.draw_enemy(enemy)

        # Draw missiles

        self.draw_missiles()

        self.root.after(30, self.update_game)  # ~33 FPS

if __name__ == "__main__":

    root = tk.Tk()

    Game(root)

    root.mainloop()