1131018-udpcast-傳送文字，改成用Tk.Text方式

伺服端

-

要將伺服端的文字輸入改成使用 tk.Text，並且設置預設的窗口大小為 400x300，你可以依以下方式修改伺服端和客戶端的程式。

伺服端程式修改

1. 創建一個使用 tk.Text 的輸入框 將 tk.simpledialog.askstring() 替換為使用 tk.Toplevel 和 tk.Text 來顯示一個可供多行輸入的窗口。

2. 設置窗口大小 你可以通過 geometry() 方法來設置窗口的大小，讓它預設為 400x300。

3. 新增確定按鈕 當使用者完成文字輸入後，按下「確定」按鈕來傳送輸入的文字。

在伺服端"# 建立廣播、傳送檔案按鈕"，右邊，希望增加一個"傳送文字"的按鈕，功能是：伺服端使用者先選擇多個clinet端電腦後才能按下"傳送文字"的按鈕，不然會提示先選clinet端電腦，接著UI會彈出一個400*300文字框讓伺服端使用者可以輸入文字(這個文字框有自動斷行的功能)，這個UI在輸入完後有送出文字的按鈕，並傳送到clinet端電腦，client端電腦會跳出一個UI界面400*300的畫面來呈現，用14的字體呈現，使用的PORT設定為8520，請要問如何修正伺服端及clinet端的程式？ 

import socket

import threading

import tkinter as tk

from tkinter import filedialog, ttk, messagebox

from tkinter.scrolledtext import ScrolledText

import time

import os

import subprocess

from tkinter.scrolledtext import ScrolledText

import psutil  # 用於獲取網路介面資訊

class Server:

    def __init__(self, root):

        self.root = root

        self.root.title("Server UDP傳送檔案")

        self.root.geometry("800x800")

        self.network_interfaces = self.get_network_interfaces()

        self.selected_interface = tk.StringVar(value=list(self.network_interfaces.keys())[0])

        # 標題與 IP 顯示

        header_frame = tk.Frame(self.root)

        header_frame.pack(pady=10)

        self.title_label = tk.Label(header_frame, text="UDP派送檔案", font=("Arial", 18), fg="deepskyblue")

        self.title_label.pack(side=tk.LEFT, pady=10)

        self.server_ip = self.get_local_ip()

        self.ip_label = tk.Label(header_frame, text=f"伺服器端 IP: {self.server_ip}", font=("Arial", 14))

        self.ip_label.pack(side=tk.LEFT, padx=(10, 0))

        # 網路卡選擇下拉選單

        self.interface_label = tk.Label(self.root, text="選擇網路卡:")

        self.interface_label.pack(pady=5)

        self.interface_dropdown = ttk.Combobox(self.root, textvariable=self.selected_interface, values=list(self.network_interfaces.keys()))

        self.interface_dropdown.pack(pady=5)

        self.interface_dropdown.bind("<<ComboboxSelected>>", self.update_ip_display)  # 綁定事件

        # 建立表格

        self.tree = ttk.Treeview(root, columns=("IP", "MAC", "Name", "Status"), show='headings')

        self.tree.heading("IP", text="IP 位置", anchor="center")

        self.tree.heading("MAC", text="MAC 位置", anchor="center")

        self.tree.heading("Name", text="電腦名稱", anchor="center")

        self.tree.heading("Status", text="狀態", anchor="center")

        self.tree.column("IP", anchor="center")

        self.tree.column("MAC", anchor="center")

        self.tree.column("Name", anchor="center")

        self.tree.column("Status", anchor="center")

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

        self.client_data_dict = {}

        # 建立廣播、傳送檔案與傳送文字按鈕

        button_frame = tk.Frame(self.root)

        button_frame.pack(pady=10)

        self.broadcast_button = tk.Button(button_frame, text="手動廣播伺服器", command=self.start_broadcast_manually)

        self.broadcast_button.pack(side=tk.LEFT, padx=5)

        self.transfer_button = tk.Button(button_frame, text="傳送檔案", command=self.select_client_and_file)

        self.transfer_button.pack(side=tk.LEFT, padx=5)

        self.send_text_button = tk.Button(button_frame, text="傳送文字", command=self.open_text_input)

        self.send_text_button.pack(side=tk.LEFT, padx=5)

        # 儲存按鈕的參考

        self.buttons = [self.broadcast_button, self.transfer_button, self.send_text_button]

        self.output_area = ScrolledText(self.root, height=10)

        self.output_area.pack(fill=tk.BOTH, pady=10)

        # 訊息區域

        self.output_area = ScrolledText(self.root, height=10)

        self.output_area.pack(fill=tk.BOTH, pady=10)

        # 備註區域

        self.footer_frame = tk.Frame(self.root)

        self.footer_frame.pack(pady=20, fill=tk.X)

        self.marquee_text = "感謝ChatGPT 感謝UDPcast    "

        self.marquee_label = tk.Label(self.footer_frame, text=self.marquee_text, font=("Arial", 12), fg="gold")

        self.marquee_label.pack(side=tk.LEFT, padx=10)

        self.fixed_label = tk.Label(self.footer_frame, text="製作者：WCS    日期：202410.01", font=("Arial", 12), fg="gold")

        self.fixed_label.pack(side=tk.RIGHT, padx=10)

        self.move_text()

        # 啟動伺服器

        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)

        self.server_socket.bind(("", 37020))

        # 啟動接收客戶端報到的線程

        threading.Thread(target=self.receive_clients, daemon=True).start()

        threading.Thread(target=self.broadcast_for_30_seconds, daemon=True).start()

    def get_network_interfaces(self):

        interfaces = {}

        for interface, addrs in psutil.net_if_addrs().items():

            for addr in addrs:

                if addr.family == socket.AF_INET:

                    interfaces[interface] = addr.address

        return interfaces

    def get_local_ip(self):

        selected_interface = self.selected_interface.get()

        return self.network_interfaces[selected_interface]

    # 更新 IP 顯示的方法

    def update_ip_display(self, event):

        self.server_ip = self.get_local_ip()  # 取得目前選擇的 IP

        self.ip_label.config(text=f"伺服器端 IP: {self.server_ip}")  # 更新 IP 標籤

    def move_text(self):

        self.marquee_text = self.marquee_text[1:] + self.marquee_text[0]

        self.marquee_label.config(text=self.marquee_text)

        self.root.after(200, self.move_text)

    def receive_clients(self):

        while True:

            try:

                data, addr = self.server_socket.recvfrom(1024)

                client_data = data.decode().split(',')

                if len(client_data) == 3:

                    client_ip, client_mac, client_name = client_data

                    if client_ip != self.server_ip:

                        self.update_or_insert_client(client_ip, client_mac, client_name, "Online")

                else:

                    self.update_output(f"接收到不完整的資料：{client_data}\n")

            except Exception as e:

                self.update_output(f"接收資料時發生錯誤: {e}\n")

    def update_or_insert_client(self, ip, mac, name, status):

        if ip in self.client_data_dict or mac in self.client_data_dict:

            item_id = self.client_data_dict.get(ip) or self.client_data_dict.get(mac)

            self.tree.item(item_id, values=(ip, mac, name, status))

        else:

            item_id = self.tree.insert("", "end", values=(ip, mac, name, status))

            self.client_data_dict[ip] = item_id

            self.client_data_dict[mac] = item_id

    def broadcast_for_30_seconds(self):

        start_time = time.time()

        while time.time() - start_time < 30:

            try:

                local_ip = self.get_local_ip()

                self.server_socket.sendto(b"Server here", ('<broadcast>', 37020))

                time.sleep(5)

            except Exception as e:

                self.update_output(f"廣播時發生錯誤: {e}\n")

        self.update_output("廣播已停止\n")

    def start_broadcast_manually(self):

        threading.Thread(target=self.broadcast_for_30_seconds, daemon=True).start()

    # 傳送文字功能

    def open_text_input(self):

        """開啟文字輸入框並傳送文字到 client 端"""

        selected_items = self.tree.selection()

        if not selected_items:

            messagebox.showwarning("警告", "請至少選擇一個 client 端")

            return

        self.text_window = tk.Toplevel(self.root)

        self.text_window.title("輸入要傳送的文字")

        self.text_window.geometry("400x300")

        self.text_input = ScrolledText(self.text_window)

        self.text_input.pack(fill=tk.BOTH, expand=True)

        send_button = tk.Button(self.text_window, text="送出", command=self.send_text_to_clients)

        send_button.pack(pady=10)

    def send_text_to_clients(self):

        selected_items = self.tree.selection()

        client_ips = [self.tree.item(item, 'values')[0] for item in selected_items]

        input_text = self.text_input.get("1.0", tk.END).strip()

        if input_text:

            for client_ip in client_ips:

                self.server_socket.sendto(input_text.encode(), (client_ip, 8520))

            self.update_output(f"已將文字傳送到 {client_ips}\n")

        else:

            messagebox.showwarning("警告", "請輸入文字")

        self.text_window.destroy()

    def select_client_and_file(self):

        selected_items = self.tree.selection()

        if not selected_items:

            messagebox.showwarning("警告", "請至少選擇一個 client 端")

            return

        client_ips = [self.tree.item(item, 'values')[0] for item in selected_items]

        file_paths = filedialog.askopenfilenames(title="選擇檔案")

        if file_paths:

            for client_ip in client_ips:

                self.prepare_file_transfer_list(client_ip, file_paths)

    def prepare_file_transfer_list(self, client_ip, file_paths):

        transfer_list = "\n".join(file_paths)

        self.update_output(f"準備傳輸檔案到 {client_ip}:\n{transfer_list}\n")

        threading.Thread(target=self.send_file_list, args=(client_ip, file_paths), daemon=True).start()

    def send_file_list(self, client_ip, file_paths):

        try:

            file_list_str = ",".join(file_paths)

            self.server_socket.sendto(file_list_str.encode(), (client_ip, 8500))

            self.update_output(f"檔案傳輸清單已傳送至 {client_ip}\n")

            time.sleep(2)

            selected_clients = self.tree.selection()

            client_count = len(selected_clients)

            for file_path in file_paths:

                if os.path.exists(file_path):

                    self.run_udp_sender(client_ip, file_path, client_count)

        except Exception as e:

            self.update_output(f"傳送檔案清單時發生錯誤: {e}\n")

    def run_udp_sender(self, client_ip, file_path, client_count):

        # 鎖定按鈕

        self.set_buttons_state(False)

        if os.path.exists(file_path):

            command = [

                'udp-sender.exe',

                '--file', file_path,

                '--port', '8500',

                '--min-receivers', str(client_count),

                '--autostart', '5'

            ]

            threading.Thread(target=self.execute_command, args=(command,), daemon=True).start()

    def execute_command(self, command):

        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)

        for stdout_line in process.stdout:

            self.update_output(stdout_line)

        for stderr_line in process.stderr:

            self.update_output(stderr_line)

        process.stdout.close()

        process.stderr.close()

        process.wait()

        # 解除鎖定按鈕

        self.set_buttons_state(True)

    def update_output(self, message):

        self.root.after(0, lambda: self.output_area.insert(tk.END, message))

        self.root.after(0, lambda: self.output_area.see(tk.END))

# 啟動伺服端

root = tk.Tk()

server = Server(root)

root.mainloop()

client端

import socket

import threading

import time

import uuid

import os

import subprocess

import re

import tkinter as tk

from tkinter.scrolledtext import ScrolledText

class Client:

    def __init__(self):

        self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        self.client_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)

    def get_mac_address(self):

        """獲取 MAC 位址"""

        mac = ':'.join(['{:02x}'.format((uuid.getnode() >> elements) & 0xff) for elements in range(0, 2*6, 2)][::-1])

        return mac

    def get_computer_name(self):

        """獲取電腦名稱"""

        return socket.gethostname()

    def send_report(self):

        """發送客戶端的報到信息 (IP、MAC、電腦名稱)"""

        while True:

            try:

                report_msg = f"{socket.gethostbyname(socket.gethostname())},{self.get_mac_address()},{self.get_computer_name()}"

                self.client_socket.sendto(report_msg.encode(), ('<broadcast>', 37020))

            except Exception as e:

                print(f"發送報到時發生錯誤: {e}")

            time.sleep(5)

    def receive_file_list(self):

        """接收檔案清單並處理接收檔案"""

        client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        client_socket.bind(("", 8500))

        while True:

            try:

                data, addr = client_socket.recvfrom(1024)

                file_list = data.decode().split(",")

                print(f"接收到的檔案清單: {file_list}")

                # 建立接收檔案的資料夾

                os.makedirs("received_files", exist_ok=True)

                # 使用 udp-receiver.exe 接收檔案並回報進度

                for file_name in file_list:

                    save_path = os.path.join("received_files", os.path.basename(file_name))

                    self.receive_file_with_progress(save_path, addr[0])

            except Exception as e:

                print(f"接收檔案清單時發生錯誤: {e}")

    def receive_file_with_progress(self, save_path, server_ip):

        """接收檔案並顯示進度"""

        client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        # 使用 Popen 來執行 udp-receiver.exe 並捕獲輸出

        process = subprocess.Popen(

            ['udp-receiver.exe', '--file', save_path, '--port', '8500'],

            stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, creationflags=subprocess.CREATE_NO_WINDOW

        )

        for line in process.stdout:

            # 假設 udp-receiver.exe 的進度輸出包含 "% complete" 等資訊

            print(f"接收進度: {line.strip()}")  # 顯示在 client 端的控制台上

            if re.search(r'(\d+)%', line):

                # 如果捕捉到進度，將其回報給 server

                client_socket.sendto(line.encode(), (server_ip, 8501))

        # 檔案接收完成

        if process.wait() == 0:

            print("檔案接收完成")

            client_socket.sendto("傳輸完成".encode(), (server_ip, 8501))

        else:

            print("檔案接收失敗")

            client_socket.sendto("傳輸失敗".encode(), (server_ip, 8501))

    def receive_text(self):

        """接收文字訊息並彈出 UI 顯示"""

        text_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        text_socket.bind(("", 8520))

        while True:

            try:

                data, addr = text_socket.recvfrom(4096)

                received_text = data.decode()

                self.show_received_text(received_text)

            except Exception as e:

                print(f"接收文字訊息時發生錯誤: {e}")

    def show_received_text(self, text):

        """顯示接收到的文字內容"""

        text_window = tk.Toplevel()

        text_window.title("接收到的文字")

        text_window.geometry("400x300")

        text_area = ScrolledText(text_window)

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

        text_area.insert(tk.END, text)

        text_area.config(state=tk.DISABLED)

    def run(self):

        """啟動客戶端，並運行多個執行緒"""

        threading.Thread(target=self.send_report, daemon=True).start()

        threading.Thread(target=self.receive_file_list, daemon=True).start()

        threading.Thread(target=self.receive_text, daemon=True).start()

        while True:

            time.sleep(1)

# 啟動客戶端

if __name__ == "__main__":

    client = Client()

    client.run()

    root = tk.Tk()

    root.title("Client 程式")

    root.geometry("400x300")

    root.mainloop()