Considering the following python code for a music player here, I want to make it so the panes for the right panel and the player controls simply overlay instead of causing the video to shrink to show the pane. Please list a few ways you would go about accomplishing this and then list the best method in your opinion then only provide code for that method (Do not output the full code, only parts you add or modify):

import os
import random
import tkinter as tk
from tkinter import filedialog, Scale
from tkinter import *
import vlc

#TODO make it so the pane on the right and the pane for the player controls overlay instead of push out of the way.
#TODO add a counter (can be true/false) just to keep track of the first instance of a video being played so that both panes won't always appear when the video is paused
# also as an extension or an alternate solution see if there is another better vlc function for this or make the player pause/play button work differently 
# make the play button on the right pane be either play or stop and set a T/F variable to show/hide the panes based on that! ie: true means video is playing and don't always show the panes and vice versa

class Song:
    def __init__(self, path, priority=50):
        self.path = path
        self.priority = priority

class MusicPlayer:
    def __init__(self, root):
        self.playlist = []
        self.root = root
        self.last_dir = "/"
        self.file_dialog_open = False  # Flag to track if file dialog is open
        self.control_frame_visible = True  # Start with the control frame visible
        self.current_song_index = -1  # Track the current song index
        self.full_screen = False  # Flag to track full screen state
        self.cursor_position_unchanged_counter = 0
        self.previous_cursor_position = (-1, -1)  # Initialize previous cursor position

        # Create frame for VLC video
        self.vlc_frame = tk.Frame(root)
        self.vlc_frame.grid(row=0, column=0, sticky="nsew")

        # VLC initialization
        self.instance = vlc.Instance()
        self.media_player = self.instance.media_player_new()

        root.after(0, self.set_vlc_window)

        # Create frame for controls and playlist
        self.control_frame = tk.Frame(root)
        self.control_frame.grid(row=0, column=1, sticky="nsew")

        # Create a File Explorer label
        label = Label(self.control_frame, text='File Explorer', width=20, height=2, fg='blue')
        label.grid(row=0, column=0, padx=10, pady=10)

        # Creating a button to open the file explorer
        button_explore = Button(self.control_frame, text='Browse Files', command=self.browseFiles)
        button_explore.grid(row=1, column=0, padx=10, pady=10)

        # Creating a button to add a directory
        button_directory = Button(self.control_frame, text='Add Directory', command=self.addDirectory)
        button_directory.grid(row=2, column=0, padx=10, pady=10)

        # Creating a button to play the music
        self.button_play = Button(self.control_frame, text='Play Music', command=self.play_music)
        self.button_play.grid(row=3, column=0, padx=10, pady=10)

        # Creating a listbox to display the playlist
        self.listbox = Listbox(self.control_frame)
        self.listbox.grid(row=4, column=0, padx=10, pady=10)

        # Create frame for media controls directly below the VLC frame
        self.media_controls = tk.Frame(root)
        self.media_controls.grid(row=1, column=0, columnspan=2, sticky="ew")

        # Adding control buttons
        self.button_rewind = Button(self.media_controls, text='<< Rewind', command=self.rewind)
        self.button_rewind.grid(row=0, column=0, padx=5)

        self.button_play_pause = Button(self.media_controls, text='Play', command=self.toggle_play_pause)
        self.button_play_pause.grid(row=0, column=1, padx=5)

        self.button_forward = Button(self.media_controls, text='Fast Forward >>', command=self.fast_forward)
        self.button_forward.grid(row=0, column=2, padx=5)

        self.button_prev_track = Button(self.media_controls, text='<< Previous', command=self.prev_track)
        self.button_prev_track.grid(row=0, column=3, padx=5)

        self.button_next_track = Button(self.media_controls, text='Next >>', command=self.next_track)
        self.button_next_track.grid(row=0, column=4, padx=5)

        # Adding a volume control
        self.volume_control = Scale(self.media_controls, from_=0, to=100, orient=HORIZONTAL, command=self.set_volume)
        self.volume_control.set(60)  # Set default volume to 50%
        self.volume_control.grid(row=0, column=5, padx=5)

        self.root.columnconfigure(0, weight=1)
        self.root.columnconfigure(1, weight=0)
        self.root.rowconfigure(0, weight=1)
        self.root.rowconfigure(1, weight=0)

        # Timer for hiding controls
        self.hide_controls_timer = None

        # Start polling for mouse position
        self.poll_mouse_position()

        # Show the control frame initially
        self.show_control_frame()


    def set_vlc_window(self):
        self.media_player.set_hwnd(self.vlc_frame.winfo_id())

    def browseFiles(self, event=None):
        self.file_dialog_open = True  # Set flag to indicate file dialog is open
        filename = filedialog.askopenfilename(initialdir=self.last_dir, title="Select a File", filetypes=(("Text files", "*.mp4*"), ("all files", "*.*")))
        self.last_dir = os.path.dirname(filename)
        self.add_song(Song(filename, 50))
        self.file_dialog_open = False  # Reset flag after file dialog is closed

    def addDirectory(self, event=None):
        self.file_dialog_open = True
        directory = filedialog.askdirectory(initialdir=self.last_dir, title="Select a Directory")
        self.last_dir = directory
        for filename in os.listdir(directory):
            if filename.endswith(".mp4"):
                self.add_song(Song(os.path.join(directory, filename), 50))
        self.file_dialog_open = False

    def add_song(self, song):
        self.playlist.append(song)
        self.listbox.insert(END, os.path.basename(song.path))

    def play_music(self, event=None):
        if not self.playlist:
            print("Playlist is empty")
            return

        probabilities = [song.priority for song in self.playlist]
        total = sum(probabilities)
        probabilities = [p/total for p in probabilities]
        selected_song = random.choices(self.playlist, probabilities)[0]

        self.current_song_index = self.playlist.index(selected_song)  # Update current song index

        media = self.instance.media_new(selected_song.path)
        self.media_player.set_media(media)
        self.media_player.play()
        self.button_play_pause.config(text="Pause")

    def toggle_play_pause(self):
        if self.media_player.is_playing():
            self.media_player.pause()
            self.button_play_pause.config(text="Play")
        else:
            self.media_player.play()
            self.button_play_pause.config(text="Pause")

    def rewind(self):
        current_time = self.media_player.get_time()
        self.media_player.set_time(max(0, current_time - 5000))

    def fast_forward(self):
        current_time = self.media_player.get_time()
        self.media_player.set_time(current_time + 5000)

    def prev_track(self):
        if self.playlist and self.current_song_index > 0:
            self.current_song_index -= 1
            self.play_selected_song()

    def next_track(self):
        if self.playlist and self.current_song_index < len(self.playlist) - 1:
            self.current_song_index += 1
            self.play_selected_song()

    def play_selected_song(self):
        selected_song = self.playlist[self.current_song_index]
        media = self.instance.media_new(selected_song.path)
        self.media_player.set_media(media)
        self.media_player.play()
        self.button_play_pause.config(text="Pause")

    def set_volume(self, volume):
        self.media_player.audio_set_volume(int(volume))

    def hide_control_frame(self):
       if self.control_frame_visible:
           self.control_frame.grid_remove()
           self.control_frame_visible = False

    def show_control_frame(self, event=None):
       if not self.control_frame_visible and not self.file_dialog_open:
           self.control_frame.grid(row=0, column=1, sticky="nsew")
           self.control_frame_visible = True

    def hide_controls(self):
        self.media_controls.grid_remove()
        self.hide_controls_timer = None

    def show_controls(self, event=None):
        self.media_controls.grid(row=1, column=0, columnspan=2, sticky="ew")
        if self.hide_controls_timer:
            self.root.after_cancel(self.hide_controls_timer)
        self.hide_controls_timer = self.root.after(4000, self.hide_controls)  # Schedule to hide controls after 4 seconds

    def poll_mouse_position(self):
        # Get the mouse position relative to the root window
        mouse_x = self.root.winfo_pointerx() - self.root.winfo_rootx()
        mouse_y = self.root.winfo_pointery() - self.root.winfo_rooty()

        window_width = self.root.winfo_width()

        # Get the mouse position relative to the VLC video area
        cursor_position = self.media_player.video_get_cursor()

        if self.media_player.is_playing():
            # Check if the cursor position is the same as the previous position
            if cursor_position == self.previous_cursor_position:
                self.cursor_position_unchanged_counter += 1
            else:
                self.cursor_position_unchanged_counter = 0

            self.previous_cursor_position = cursor_position

            # If the cursor position is unchanged for 40 checks (4 seconds), hide the controls
            if self.cursor_position_unchanged_counter >= 40:
                self.hide_controls()
            else:
                self.show_controls()

            # Check if mouse is near the right edge for context menu visibility
            if mouse_x >= window_width - 100:
                self.show_control_frame()
            else:
                self.hide_control_frame()

        else:
            # Reset the counter and make sure the controls are visible while the video is not playing
            self.cursor_position_unchanged_counter = 0
            self.show_controls()
            self.show_control_frame()

        # Schedule the next poll
        self.root.after(100, self.poll_mouse_position)

# Create the root window
root = Tk()
root.title('Music Player')
root.geometry("800x500")

# Create the MusicPlayer
player = MusicPlayer(root)

# Run the application
root.mainloop()