PianoRoll.py

import bisect

import pygame
import pygame.gfxdraw
import pygame.midi
import sys

from UIComponents import Button, Scrollbar
from Config import WHITE, BLACK, DARK_GRAY, RED, WINDOW_W, WINDOW_H, \
    KEY_W, NOTES, BAR_HEIGHT, \
    NOTE_NAMES, SCROLLBAR_W, TOOLBAR_H,\
    TRACK_COLORS, PPQ, fonts, BAR_COLOR, TRACKS_HEIGHT
from Note import Note

from utils import is_black, clamp, get_note_name


# ---------------- PianoRoll ----------------
class PianoRoll:
    def __init__(self, midi_manager):
        # 1. Core Engine & State
        self.current_playhead_px = 0
        self.last_frame_tick = 0
        self.draw_measure = True
        self.draw_beats = True
        self.draw_8ths = True
        self.draw_32nds = False
        self.label_step = 1
        self.draw_16ths = True
        self.midi_manager = midi_manager
        self.previewing_note = None
        self.dragging_playhead = False
        self.clipboard = []
        self.selected_notes = []
        self.last_hovered_key_idx = None
        # 2. Viewport & Scaling Constants
        self.margin = 10
        self.zoom_speed = 0.25
        self.zoom_anchor_tick = 0
        self.update_scale_mask()
        # 3. Layout Dimensions
        self.bar_height = BAR_HEIGHT
        self.scaled_key_w = KEY_W
        self.roll_x = self.scaled_key_w + self.margin
        self.roll_y = TOOLBAR_H + self.bar_height
        self.last_note_duration = PPQ
        self.last_note_velocity = 64

        # Calculate width/height based on window config
        self.roll_w = WINDOW_W - self.roll_x - self.margin
        self.roll_h = WINDOW_H - self.roll_y - self.margin - TRACKS_HEIGHT

        # 4. Project Length Initialization
        # Calculate the initial 8-bar chunked boundary immediately
        self.midi_manager.update_project_length()

        # 5. Zoom & Grid Settings
        self.cell_h = 16
        self.max_cell_h = 40
        self.min_cell_h = self.roll_h / 128

        # Set starting view: fit exactly 8 bars into the window
        bars_to_fit_8 = 5 * self.midi_manager.time_signature[0]
        self.cell_w = self.roll_w / max(1, bars_to_fit_8)
        self.target_cell_w = self.cell_w  # Prevents startup "zoom jump"

        # Set Max Zoom Limit: exactly 2 bars
        bars_to_fit_2 = 2 * self.midi_manager.time_signature[0]
        self.max_cell_w = self.roll_w / max(1, bars_to_fit_2)


        # 6. Fonts
        self.notes_surface = pygame.Surface((self.roll_w, self.roll_h), pygame.SRCALPHA).convert_alpha()
        self.notes_need_update = True  # New flag for dirty note rendering

        # 7. Scrollbars & Surfaces
        h_content_px = self.ticks_to_pixel(self.midi_manager.project_end_tick)
        v_content_px = 128 * self.cell_h

        self.h_scroll = Scrollbar(
            self.roll_x, self.roll_y + self.roll_h - SCROLLBAR_W,
                         self.roll_w - SCROLLBAR_W, SCROLLBAR_W,
            content_size=h_content_px, viewport_size=self.roll_w, orientation='horizontal'
        )

        self.v_scroll = Scrollbar(
            self.roll_x + self.roll_w - SCROLLBAR_W, self.roll_y,
            SCROLLBAR_W, self.roll_h,
            content_size=v_content_px, viewport_size=self.roll_h, orientation='vertical'
        )

        # 8. Visual Elements & Interaction
        self.offset_x = 0
        self.offset_y = max(0, (v_content_px // 2) - (self.roll_h // 2))  # Center on Middle C area
        self.v_scroll.offset = self.offset_y

        self.selection_rect = None
        self.dragging_scroll = False
        self.selection_start_pos = None

        self.keys_viewport = pygame.Surface((self.scaled_key_w, self.roll_h)).convert()

        self.bar_rect = pygame.Rect(self.roll_x, self.roll_y - self.bar_height, self.roll_w, self.bar_height)
        self.roll_rect = pygame.Rect(self.roll_x, self.roll_y, self.roll_w, self.roll_h)
        self.bar_surface = pygame.Surface((self.roll_w, self.bar_height)).convert()

        # 9. Key Buttons (Piano Keys)
        self.key_buttons = []
        for i in range(128):
            midi_val = 127 - i
            name = f"{NOTE_NAMES[midi_val % 12]}{(midi_val // 12) - 1}"
            base_col = (30, 30, 30) if is_black(midi_val) else WHITE
            text_col = WHITE if is_black(midi_val) else BLACK

            btn = Button(0, 0, self.scaled_key_w, self.cell_h, name,
                         color=base_col, text_color=text_col, border_radius=0, border=True,
                         callback=lambda n=i: self._trigger_preview(n, 100))
            self.key_buttons.append(btn)

        self.grid_needs_update = True
        self.grid_surface = pygame.Surface((self.roll_w, self.roll_h)).convert()  # Opaque for speed
        # 10. Final Sync

        self.sync_project_boundaries()

    def ticks_to_pixel(self, ticks):
        return (ticks / PPQ) * self.cell_w

    def pixel_to_ticks(self, px):
        # New: Multiply first, then divide to keep precision
        denominator = max(1e-6, self.cell_w)
        return int((px * PPQ) / denominator)

    def get_snapped_ticks(self, raw_ticks):
        tps = self.midi_manager.ticks_per_snap
        return (raw_ticks // tps) * tps

    def resize(self, width, height):
        self.grid_needs_update = True
        self.notes_need_update = True

        # 1. CAPTURE STATE BEFORE RESIZE
        # Find the tick currently at the horizontal center of the viewport
        center_tick = self.pixel_to_ticks(self.offset_x + self.roll_w / 2)
        # Vertical zoom ratio (how many notes were visible)
        top_note_index = self.offset_y / self.cell_h if self.cell_h > 0 else 60
        visible_notes_count = self.roll_h / self.cell_h
        visible_beats = self.roll_w / self.cell_w if self.cell_w > 0 else 0
        self.roll_x = self.scaled_key_w + self.margin
        self.roll_w = width - self.roll_x - self.margin
        self.roll_h = height - self.roll_y - self.margin - TRACKS_HEIGHT

        # 3. APPLY VERTICAL SCALING
        self.cell_h = self.roll_h / visible_notes_count
        self.min_cell_h = self.roll_h / 128
        self.cell_h = max(self.min_cell_h, min(self.cell_h, self.max_cell_h))

        # 4. APPLY HORIZONTAL SCALING (Maintain 8-bar zoom)
        self.target_cell_w = self.roll_w / visible_beats

        # Update min_cell_w based on project length so you can't zoom out into nothing
        self.min_cell_w = self.roll_w / max(1, self.midi_manager.total_beats)

        self.target_cell_w = max(self.min_cell_w, min(self.target_cell_w, self.max_cell_w))
        self.cell_w = self.target_cell_w

        self.keys_viewport = pygame.Surface((self.scaled_key_w, self.roll_h)).convert()

        # 5. RE-CENTER HORIZONTAL VIEW
        # Calculate where the new offset should be to keep that center_tick in the middle
        new_center_px = self.ticks_to_pixel(center_tick)
        self.offset_x = new_center_px - (self.roll_w / 2)
        # Vertical: Keep the top_note_index at the top of the viewport
        # This is the "Maintain Vertical Position" fix
        self.offset_y = top_note_index * self.cell_h

        # 6. RE-INITIALIZE SURFACES
        self.roll_rect = pygame.Rect(self.roll_x, self.roll_y, self.roll_w, self.roll_h)
        self.bar_surface = pygame.Surface((self.roll_w, self.bar_height)).convert()

        # 7. SYNC SCROLLBARS & CLAMP
        h_content_px = self.ticks_to_pixel(self.midi_manager.project_end_tick)
        v_content_px = 128 * self.cell_h

        self.offset_x = max(0, min(self.offset_x, max(0, h_content_px - self.roll_w)))
        self.offset_y = max(0, min(self.offset_y, max(0, v_content_px - self.roll_h)))

        self.h_scroll.rect = pygame.Rect(self.roll_x, self.roll_y + self.roll_h - SCROLLBAR_W,
                                         self.roll_w - SCROLLBAR_W, SCROLLBAR_W)
        self.h_scroll.viewport_size = self.roll_w
        self.h_scroll.content_size = h_content_px
        self.h_scroll.offset = self.offset_x

        self.v_scroll.rect = pygame.Rect(self.roll_x + self.roll_w - SCROLLBAR_W, self.roll_y, SCROLLBAR_W, self.roll_h)
        self.v_scroll.viewport_size = self.roll_h
        self.v_scroll.content_size = v_content_px
        self.v_scroll.offset = self.offset_y
        self.notes_surface = pygame.Surface((self.roll_w, self.roll_h), pygame.SRCALPHA).convert_alpha()

        self.grid_surface = pygame.Surface((self.roll_w, self.roll_h)).convert()  # Opaque for speed

    def draw_keys(self):
        self.keys_viewport.fill((30, 30, 33))
        start_idx = int(self.offset_y // self.cell_h)
        end_idx = int((self.offset_y + self.roll_h) // self.cell_h) + 1

        for i in range(start_idx, min(128, end_idx)):
            # Calculate the actual MIDI pitch for this index
            midi_val = 127 - i
            btn = self.key_buttons[i]

            # Update position for the current frame
            btn.rect.y = (i * self.cell_h) - self.offset_y
            btn.rect.height = self.cell_h

            # CHECK HIGHLIGHTING: Is this note active in the MIDI Manager?
            is_pressed = midi_val in self.midi_manager.active_notes_set

            if not is_pressed:
                btn.color = (30, 30, 30) if is_black(midi_val) else (250, 250, 250)

            btn.draw(self.keys_viewport)

    def draw_bars(self):
        """
        Renders the timeline ruler at the top of the piano roll with
        dynamic label density based on zoom level.
        """
        self.bar_surface.fill(BAR_COLOR)

        ticks_per_bar = self.midi_manager.ticks_per_bar

        first_bar = int(self.start_tick // ticks_per_bar)
        last_bar = int(self.end_tick // ticks_per_bar) + 1

        for b in range(first_bar, last_bar):
            # Calculate pixel position relative to the scroll offset
            px = self.ticks_to_pixel(b * ticks_per_bar) - self.offset_x
            if b % self.label_step == 0:
                text = fonts[12].render(f"{b + 1}", True, BLACK)
                if px + 5 < self.roll_w:
                    self.bar_surface.blit(text, (px + 5, 2))


        # self.draw_tempo_markers()

        if 0 <= self.current_playhead_px <= self.roll_w:
            points = [
                (self.current_playhead_px - 8, 0),
                (self.current_playhead_px + 8, 0),
                (self.current_playhead_px, 10)
            ]
            pygame.gfxdraw.filled_polygon(self.bar_surface, points, RED)
            pygame.gfxdraw.aapolygon(self.bar_surface, points, RED)

    # def draw_tempo_markers(self):
    #     # Calculate visible range
    #
    #
    #     for tick, bpm in self.midi_manager.tempo_map:
    #         if self.start_tick <= tick <= self.end_tick:
    #             # Convert tick to pixel position relative to the bar surface
    #             px = self.ticks_to_pixel(tick) - self.offset_x
    #
    #             # Draw a small flag or line on the bar_surface
    #             pygame.draw.line(self.bar_surface, (0, 100, 255), (px, 0), (px, self.bar_height), 2)
    #
    #             # Draw the BPM text
    #             bpm_text = fonts[10].render(f"= {round(bpm)}", True, (0, 50, 150))
    #             self.bar_surface.blit(bpm_text, (px + 4, 20))

    def draw(self, screen):
        self.sync_project_boundaries()
        self.update_auto_scroll()  # Follow playhead

        self.start_tick = self.pixel_to_ticks(self.offset_x)
        self.end_tick = self.pixel_to_ticks(self.offset_x + self.roll_w)
        self.update_zoom()  # Logic for smooth zoom
        self._handle_drag_scrolling()  # Move view when dragging notes
        self._handle_continuous_playhead_scroll()
        self.current_playhead_px = self.ticks_to_pixel(self.midi_manager.play_tick) - self.offset_x
        # 1. Draw the Timeline Bar directly to screen
        self.draw_roll(screen)  # Pass the main screen here
        self.draw_keys()
        self.draw_bars()
        screen.blit(self.bar_surface, (self.roll_x, self.roll_y - self.bar_height))

        # 3. Draw Keys
        screen.blit(self.keys_viewport, (self.roll_x - KEY_W, self.roll_y))

        # 4. Draw scrollbars
        self.h_scroll.draw(screen)
        self.v_scroll.draw(screen)


    def handle_event(self, event):
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()

        if self.h_scroll.handle_event(event):
            self.offset_x, self.offset_y = int(self.h_scroll.offset), int(self.v_scroll.offset)
            self.grid_needs_update = True
            self.notes_need_update = True
            return

        if self.v_scroll.handle_event(event):
            self.offset_x, self.offset_y = int(self.h_scroll.offset), int(self.v_scroll.offset)
            self.grid_needs_update = True
            self.notes_need_update = True
            return

        if event.type == pygame.MOUSEBUTTONDOWN:
            if self._handle_click(event):
                return

        elif event.type == pygame.MOUSEBUTTONUP:
            if self._handle_mouse_up(event):
                return


        elif event.type == pygame.MOUSEMOTION:
            if self._handle_mouse_motion(event):
                return

        elif event.type == pygame.MOUSEWHEEL:
            self._handle_zoom_and_scroll(event)
            return


        elif event.type == pygame.KEYDOWN:
            self._handle_shortcuts(event)
            return

    def _handle_shortcuts(self, event):
        mods = pygame.key.get_mods()
        ctrl = mods & pygame.KMOD_CTRL
        shift = mods & pygame.KMOD_SHIFT
        tps = self.midi_manager.ticks_per_snap
        # 1. NON-MODIFIER KEYS

        if not ctrl and not shift:
            if event.key in (pygame.K_DELETE, pygame.K_BACKSPACE):
                if self.selected_notes:
                    self.midi_manager.save_history()
                    # Filter notes out of their respective tracks
                    for track_idx in range(len(self.midi_manager.tracks)):
                        self.midi_manager.tracks[track_idx] = [
                            n for n in self.midi_manager.tracks[track_idx]
                            if n not in self.selected_notes
                        ]

                    self.selected_notes.clear()
                    self.notes_need_update = True
                    self.midi_manager.update_project_length()

        # 2. CTRL COMBINATIONS

        elif ctrl:
            # State-changing actions (Undo/Redo/Select All)
            if event.key == pygame.K_z:

                self.redo() if shift else self.undo()

            elif event.key == pygame.K_a:

                self.selected_notes.clear()

                self.selected_notes.extend(self.midi_manager.tracks[self.midi_manager.active_track_index])
                self.notes_need_update = True

            elif event.key == pygame.K_c:

                self.copy()

            elif event.key == pygame.K_v:

                self.paste()
                self.notes_need_update = True

            # Batch transformations (save history once)

            elif event.key in (pygame.K_UP, pygame.K_DOWN, pygame.K_q) and self.selected_notes:
                self.midi_manager.save_history()
                for note in self.selected_notes:
                    if event.key == pygame.K_UP:
                        note.y = max(0, note.y - 12)
                        self.notes_need_update = True

                    elif event.key == pygame.K_DOWN:
                        note.y = min(127, note.y + 12)
                        self.notes_need_update = True

                    elif event.key == pygame.K_q:
                        note.x = max(0, ((note.x + tps // 2) // tps) * tps)
                        self.notes_need_update = True

        # 3. SHIFT COMBINATIONS (Nudging / Semitones)

        elif shift:
            if event.key in (pygame.K_UP, pygame.K_DOWN, pygame.K_LEFT, pygame.K_RIGHT) and self.selected_notes:
                self.midi_manager.save_history()
                for note in self.selected_notes:
                    if event.key == pygame.K_UP:
                        note.y = max(0, note.y - 1)
                    elif event.key == pygame.K_DOWN:
                        note.y = min(127, note.y + 1)

                    elif event.key == pygame.K_LEFT:
                        note.x = max(0, note.x - tps)

                    elif event.key == pygame.K_RIGHT:
                        note.x += tps

                # Preview only once after the loop

                if event.key in (pygame.K_UP, pygame.K_DOWN):
                    self._trigger_preview(self.selected_notes[0].y)

    def _handle_mouse_motion(self, event):
        # Always update the visual cursor first
        self._update_cursor_icon(event.pos)
        if self.dragging_scroll:
            self._handle_scrolling(event.pos)
            return

        # 1. Viewport & Playhead (Global UI)
        if self.dragging_playhead:
            self._handle_playhead_drag(event.pos)
            return

        if any(n.dragging or n.resizing for n in self.midi_manager.notes):
            self._handle_note_transformation(event.pos)
            return

        # 3. Selection Tools (Lasso)
        if self.selection_start_pos:
            self._handle_lasso_logic(event.pos)
            return

        # 4. Eraser (Right Click)
        if pygame.mouse.get_pressed()[2]:
            snapped_x, grid_y = self.get_grid_coords(event.pos)
            self.midi_manager.remove_note_at(snapped_x, grid_y)
            self.notes_need_update = True

        else:
            if event.pos[0] < self.roll_x:
                raw_y = event.pos[1] - self.roll_y
                # Calculate index based on the scroll position
                current_key_idx = int((raw_y + self.offset_y) // self.cell_h)

                # 2. Reset the previous button's hover state if we moved to a new index
                if self.last_hovered_key_idx is not None and self.last_hovered_key_idx != current_key_idx:
                    if 0 <= self.last_hovered_key_idx < 128:
                        off_event = pygame.event.Event(pygame.MOUSEMOTION, {'pos': (-1, -1), 'buttons': (0, 0, 0)})
                        self.key_buttons[self.last_hovered_key_idx].handle_event(off_event)

                # 3. Trigger the CURRENT button
                if 0 <= current_key_idx < 128:
                    btn = self.key_buttons[current_key_idx]

                    # CRITICAL FIX: The button's internal rect.y is updated in draw_keys.
                    # We must pass the GLOBAL mouse position (relative to the screen/viewport)
                    # so btn.rect.collidepoint(event.pos) works.
                    global_y_for_btn = event.pos[1] - self.roll_y
                    btn_event = pygame.event.Event(event.type, {
                        'pos': (event.pos[0], global_y_for_btn),
                        'button': getattr(event, 'button', 1)
                    })

                    btn.handle_event(btn_event)
                    self.last_hovered_key_idx = current_key_idx
            elif self.last_hovered_key_idx is not None:
                off_event = pygame.event.Event(pygame.MOUSEMOTION, {'pos': (-1, -1), 'buttons': (0, 0, 0)})
                self.key_buttons[self.last_hovered_key_idx].handle_event(off_event)
                self.last_hovered_key_idx = None

    def _handle_click(self, event):
        # 1. Timeline / Playhead Interaction
        if self.bar_rect.collidepoint(event.pos):
            rel_x = event.pos[0] - self.roll_x + self.offset_x
            raw_tick = self.pixel_to_ticks(rel_x)
            snapped_tick = self.get_snapped_ticks(raw_tick)

            if event.button == 1:  # Left Click: Move Playhead
                self.midi_manager.play_tick = max(0, raw_tick)
                self.dragging_playhead = True


        # 2. Piano Roll Interaction
        if self.roll_rect.collidepoint(event.pos):
            mods = pygame.key.get_mods()
            ctrl_held = mods & pygame.KMOD_CTRL

            raw_x_tick = self.get_raw_ticks(event.pos[0])
            snapped_ticks, y_grid = self.get_grid_coords(event.pos)

            # Find if a note exists at the exact mouse position
            note = self.midi_manager.find_note_at(raw_x_tick, y_grid)

            if event.button == 1:  # Left Click
                if note:
                    # Save history ONCE before any transformation begins
                    self.midi_manager.save_history()

                    # Selection Logic: If clicking an unselected note, make it the only selection
                    if note not in self.selected_notes:
                        self.selected_notes = [note]

                    # Determine if we are Resizing, Editing Velocity, or Moving
                    # Use a 12px handle for resizing
                    note_start_px = self.ticks_to_pixel(note.x) - self.offset_x
                    note_width_px = self.ticks_to_pixel(note.length)
                    mouse_rel_x_px = event.pos[0] - self.roll_x - note_start_px

                    mode = "move"
                    if mouse_rel_x_px > (note_width_px - 12):
                        mode = "resize"

                    # CRITICAL: Lock the starting state for EVERY note in the selection
                    for n in self.selected_notes:
                        n.start_drag(raw_x_tick, y_grid, mode=mode)
                        n.drag_start_pos = event.pos  # Store pixels for velocity sensitivity


                    # 🔊 Preview the note being clicked
                    self._trigger_preview(note.y, note.velocity)

                elif ctrl_held:
                    # Start Lasso Selection
                    self.selection_start_pos = event.pos
                    self.selected_notes.clear()


                # Inside PianoRoll._handle_click

                elif len(self.selected_notes) == 0:
                    self.midi_manager.save_history()
                    new_note = Note(snapped_ticks, y_grid, length=self.last_note_duration,
                                    velocity=self.last_note_velocity)
                    # This automatically targets the active track via the property
                    self.midi_manager.add_note(new_note)
                    self.notes_need_update = True

                    new_note.start_drag(raw_x_tick, y_grid, mode="move")
                    self._trigger_preview(new_note.y, new_note.velocity)

                else:
                    self.selected_notes.clear()
                    self.notes_need_update = True


            elif event.button == 3:  # Right Click: Delete
                self.midi_manager.save_history()
                self.midi_manager.remove_note_at(snapped_ticks, y_grid)
                self.notes_need_update = True

            elif event.button == 2:  # Middle Click: Pan View
                self.dragging_scroll = True
                self.scroll_start = event.pos
                self.offset_start = (self.offset_x, self.offset_y)

            self._update_cursor_icon(event.pos)

    def _handle_zoom_and_scroll(self, event):
        mods = pygame.key.get_mods()
        m_pos = pygame.mouse.get_pos()

        if mods & pygame.KMOD_ALT:
            # Determine velocity change (e.g., 5 units per scroll notch)
            velocity_delta = 5 if event.y > 0 else -5

            # If there's a selection, adjust the whole group
            if self.selected_notes:
                for note in self.selected_notes:
                    note.velocity = clamp(note.velocity + velocity_delta, 1, 127)
            else:
                # Otherwise, adjust the note currently under the mouse
                x_tick, y_grid = self.get_grid_coords(m_pos)
                hovered_note = self.midi_manager.find_note_at(x_tick, y_grid)
                if hovered_note:
                    hovered_note.velocity = clamp(hovered_note.velocity + velocity_delta, 1, 127)

            # Return early so we don't zoom/scroll while editing velocity
            self.notes_need_update = True

            return

        # Capture the MIDI tick currently under the mouse to use as a zoom anchor
        rel_x = self.offset_x + (m_pos[0] - self.roll_x)
        rel_y = self.offset_y + (m_pos[1] - self.roll_y)

        self.zoom_anchor_tick = self.pixel_to_ticks(rel_x)

        if mods & pygame.KMOD_CTRL:
            # We are only doing horizontal smooth zoom
            factor = 1.1 if event.y > 0 else 0.9

            if not (mods & pygame.KMOD_SHIFT):
                # 1. Recalculate minimum zoom based on current window/project size
                total_ticks = self.midi_manager.project_end_tick
                # min_cell_w = pixels_available / total_steps_in_project
                total_steps = (total_ticks / PPQ) * self.midi_manager.steps_per_beat
                self.min_cell_w = self.roll_w / max(0.1, total_steps)
                # 2. Apply zoom factor to target
                self.target_cell_w = clamp(self.target_cell_w * factor, self.min_cell_w, self.max_cell_w)

            else:
                old_h = self.cell_h
                # Update the limit calculation right before clamping
                self.min_cell_h = self.roll_h / 128

                self.cell_h = clamp(self.cell_h * factor, self.min_cell_h, self.max_cell_h)

                # Re-anchor Y to keep the mouse position consistent
                self.offset_y = (rel_y * (self.cell_h / old_h)) - (m_pos[1] - self.roll_y)
        else:
            # Standard Scroll (Y-axis)
            scroll_dist = self.cell_h * 3
            self.offset_y = clamp(self.offset_y - event.y * scroll_dist, 0, (128 * self.cell_h) - self.roll_h)
            self.v_scroll.offset = self.offset_y

        h_content_px = self.ticks_to_pixel(self.midi_manager.project_end_tick)
        v_content_px = 128 * self.cell_h


        self.h_scroll.rect = pygame.Rect(self.roll_x, self.roll_y + self.roll_h - SCROLLBAR_W, self.roll_w - SCROLLBAR_W,
                                         SCROLLBAR_W)
        self.h_scroll.content_size = h_content_px
        self.h_scroll.viewport_size = self.roll_w

        self.v_scroll.rect = pygame.Rect(self.roll_x + self.roll_w - SCROLLBAR_W, self.roll_y,
                                         SCROLLBAR_W,
                                         self.roll_h)
        self.v_scroll.content_size = v_content_px
        self.v_scroll.viewport_size = self.roll_h

        self.offset_x = max(0, min(self.offset_x, h_content_px - self.roll_w))
        self.offset_y = max(0, min(self.offset_y, v_content_px - self.roll_h))

        # Sync Scrollbars
        self.h_scroll.offset = self.offset_x
        self.v_scroll.offset = self.offset_y
        self.grid_needs_update = True

        self.notes_need_update = True

    def _handle_drag_scrolling(self):
        """Performs scrolling every frame if a note is being dragged outside the viewport."""
        # Only scroll if we are actually dragging or resizing a note
        if not any(n.dragging or n.resizing for n in self.midi_manager.notes):
            return

        pos = pygame.mouse.get_pos()
        scroll_speed = 2  # Adjusted for per-frame execution
        changed = False

        # Horizontal Scroll
        if pos[0] < self.roll_rect.left:
            self.offset_x = max(0, self.offset_x - scroll_speed)
            changed = True
        elif pos[0] > self.roll_rect.right:
            max_scroll_x = max(0, self.h_scroll.content_size - self.roll_w)
            self.offset_x = min(max_scroll_x, self.offset_x + scroll_speed)
            changed = True

        # Vertical Scroll
        if pos[1] < self.roll_rect.top:
            self.offset_y = max(0, self.offset_y - scroll_speed)
            changed = True
        elif pos[1] > self.roll_rect.bottom:
            max_scroll_y = max(0, (128 * self.cell_h) - self.roll_h)
            self.offset_y = min(max_scroll_y, self.offset_y + scroll_speed)
            changed = True

        if changed:
            self.h_scroll.offset = self.offset_x
            self.v_scroll.offset = self.offset_y
            # Re-apply transformation logic so notes stay glued to the mouse during scroll
            self._handle_note_transformation(pos)
            self.grid_needs_update = True

            self.notes_need_update = True

    def _handle_mouse_up(self, event):
        if event.button == 2:  # Middle Mouse Up
            self.dragging_scroll = False

        elif event.button == 1:
            # Silence the note currently being previewed
            if self.previewing_note is not None:
                self.midi_manager.note_off(self.previewing_note)
                self.previewing_note = None  # Reset so it can be re-triggered later
            # ----------------------
            active_note = next((n for n in self.midi_manager.notes if n.dragging or n.resizing), None)
            if active_note:
                self.last_note_duration = active_note.length
                self.last_note_velocity = active_note.velocity

            self.dragging_playhead = False
            self.selection_start_pos = None
            self.selection_rect = None

            for note in self.midi_manager.notes:
                note.stop_drag()
                note.editing_velocity = False  # Reset velocity mode

    def _handle_lasso_logic(self, pos):
        # 1. Calculate the raw rectangle in screen space
        x = min(self.selection_start_pos[0], pos[0])
        y = min(self.selection_start_pos[1], pos[1])
        w = abs(self.selection_start_pos[0] - pos[0])
        h = abs(self.selection_start_pos[1] - pos[1])
        self.selection_rect = pygame.Rect(x, y, w, h)

        # 2. Convert the lasso rect to "Roll Space"
        check_rect = self.selection_rect.move(-self.roll_x, -self.roll_y)

        self.selected_notes.clear()

        # FIX: Only iterate through the active track instead of all tracks
        active_track_notes = self.midi_manager.tracks[self.midi_manager.active_track_index]

        for note in active_track_notes:
            # Calculate note position relative to the viewport
            nx = self.ticks_to_pixel(note.x) - self.offset_x
            ny = (note.y * self.cell_h) - self.offset_y
            nw = max(2, self.ticks_to_pixel(note.length))

            note_rect = pygame.Rect(nx, ny, nw, self.cell_h)

            # Check collision in Viewport Space
            if check_rect.colliderect(note_rect):
                self.selected_notes.append(note)

        # Mark notes as dirty so the selection highlight renders
        self.notes_need_update = True

    def _handle_note_transformation(self, pos):
        """
        Handles moving, resizing, and velocity editing with group integrity.
        """
        # 1. Identify the note being actively manipulated
        active_note = next((n for n in self.midi_manager.notes if n.dragging or n.resizing or n.editing_velocity), None)
        if not active_note:
            return

        # 2. Setup environment variables
        raw_x = self.get_raw_ticks(pos[0])
        _, grid_y = self.get_grid_coords(pos)
        tps = self.midi_manager.ticks_per_snap
        mods = pygame.key.get_mods()
        alt_held = mods & pygame.KMOD_ALT

        # Calculate mouse movement deltas since the initial click
        delta_tick = raw_x - active_note.drag_start_tick
        delta_grid_y = grid_y - active_note.drag_start_grid_y

        # --- MODE A: VELOCITY EDITING ---
        if active_note.editing_velocity:
            # Vertical mouse movement adjusts velocity
            # We use pos[1] directly for pixel-perfect sensitivity
            v_delta = active_note.drag_start_pos[1] - pos[1]

            for n in (self.selected_notes if active_note in self.selected_notes else [active_note]):
                n.velocity = clamp(n.start_velocity + v_delta, 1, 127)

        # --- MODE B: DRAGGING (MOVE) ---
        elif active_note.dragging:
            old_pitch = active_note.y  # Store for preview logic

            # Calculate horizontal displacement with snapping
            if alt_held:
                disp_x = delta_tick
            else:
                # Snap the new position of the anchor, then find the diff from its start
                snapped_new_x = round((active_note.start_x + delta_tick) / tps) * tps
                disp_x = snapped_new_x - active_note.start_x

            disp_y = delta_grid_y

            # Apply displacement to the group to maintain relative positions
            if active_note in self.selected_notes:
                # Group Boundary Validation
                leftmost = min(n.start_x for n in self.selected_notes)
                if leftmost + disp_x < 0: disp_x = -leftmost

                min_y = min(n.start_y for n in self.selected_notes)
                max_y = max(n.start_y for n in self.selected_notes)
                if min_y + disp_y < 0: disp_y = -min_y
                if max_y + disp_y > 127: disp_y = 127 - max_y

                for n in self.selected_notes:
                    n.x = n.start_x + disp_x
                    n.y = n.start_y + disp_y
            else:
                # Individual drag
                active_note.x = max(0, active_note.start_x + disp_x)
                active_note.y = clamp(active_note.start_y + disp_y, 0, 127)

            # Trigger preview only if the active note's pitch changed
            if active_note.y != old_pitch:
                self._trigger_preview(active_note.y, active_note.velocity)

        # --- MODE C: RESIZING ---
        elif active_note.resizing:
            if alt_held:
                disp_len = delta_tick
            else:
                # Snap the length change to the grid
                snapped_new_end = round((active_note.start_x + active_note.start_length + delta_tick) / tps) * tps
                disp_len = snapped_new_end - (active_note.start_x + active_note.start_length)

            target_group = self.selected_notes if active_note in self.selected_notes else [active_note]

            # Prevent notes from having 0 or negative length
            min_possible_disp = min(n.start_length - (1 if alt_held else tps) for n in target_group)
            actual_disp = max(-min_possible_disp, disp_len)

            for n in target_group:
                n.length = n.start_length + actual_disp

        # 4. Final Housekeeping
        self.notes_need_update = True

        self.midi_manager.update_project_length()
        self.sync_project_boundaries()

    def _update_cursor_icon(self, pos):
        new_cursor = pygame.SYSTEM_CURSOR_ARROW

        # 1. Ensure we are inside the roll area
        if self.roll_rect.collidepoint(pos):
            # 2. Use RAW ticks for detection, not snapped grid coords
            raw_x_tick = self.get_raw_ticks(pos[0])

            # Calculate grid_y (this remains consistent as it's just pixel division)
            grid_y = int((pos[1] + self.offset_y - self.roll_y) // self.cell_h)

            # 3. Find the note using the exact tick under the mouse
            note = self.midi_manager.find_note_at(raw_x_tick, grid_y)

            if note:
                # 4. Use the note's actual x (even if off-grid) to find the handle
                note_start_px = self.ticks_to_pixel(note.x) - self.offset_x
                note_width_px = self.ticks_to_pixel(note.length)

                # Calculate mouse position relative to the note's actual start
                mouse_rel_x_px = (pos[0] - self.roll_x) - note_start_px

                # Define the resize handle (e.g., last 12 pixels of the note)
                resize_handle_width = min(8, note_width_px / 2)

                if mouse_rel_x_px > (note_width_px - resize_handle_width):
                    new_cursor = pygame.SYSTEM_CURSOR_SIZEWE  # Resize icon
                else:
                    new_cursor = pygame.SYSTEM_CURSOR_HAND  # Move icon

        pygame.mouse.set_cursor(new_cursor)

    def _handle_playhead_drag(self, pos):


        # Calculate position relative to the current scroll offset
        rel_x = pos[0] - self.roll_x + self.offset_x
        raw_tick = self.pixel_to_ticks(rel_x)

        # NEW: Snap the calculated tick to the current grid resolution
        target_tick = self.get_snapped_ticks(raw_tick)

        # Update the manager's playhead
        self.midi_manager.play_tick = max(0, target_tick)

    def _handle_continuous_playhead_scroll(self):
        """Call this every frame in PianoRoll.draw() or update()"""
        if not self.dragging_playhead:
            return

        pos = pygame.mouse.get_pos()
        scroll_speed = 5  # Increased speed for better feel during snap
        changed = False

        # Scroll Right/Left logic remains the same
        if pos[0] > self.roll_rect.right:
            max_scroll = max(0, self.h_scroll.content_size - self.roll_w)
            if self.offset_x < max_scroll:
                self.offset_x = min(max_scroll, self.offset_x + scroll_speed)
                changed = True
        elif pos[0] < self.roll_rect.left:
            if self.offset_x > 0:
                self.offset_x = max(0, self.offset_x - scroll_speed)
                changed = True

        if changed:
            self.h_scroll.offset = self.offset_x
            # This now calls the updated _handle_playhead_drag with snapping
            self._handle_playhead_drag(pos)
            self.grid_needs_update = True
            self.notes_need_update = True

    def _handle_scrolling(self, pos):
        # Calculate how far the mouse has moved from the initial click
        dx = pos[0] - self.scroll_start[0]
        dy = pos[1] - self.scroll_start[1]

        # Update offsets based on the starting position minus the movement
        # max(0, ...) prevents scrolling into negative space
        self.offset_x = max(0, self.offset_start[0] - dx)
        self.offset_y = max(0, self.offset_start[1] - dy)
        h_max = max(0, self.h_scroll.content_size - self.roll_w)
        v_max = max(0, (128 * self.cell_h) - self.roll_h)
        self.offset_x = min(self.offset_x, h_max)
        self.offset_y = min(self.offset_y, v_max)
        # Sync the scrollbar UI objects (if they exist)
        self.h_scroll.offset = self.offset_x
        self.v_scroll.offset = self.offset_y

        self.grid_needs_update = True

        self.notes_need_update = True

    def _trigger_preview(self, grid_y, velocity=64):
        midi_note = (NOTES - 1) - grid_y

        if self.previewing_note != midi_note:
            if self.previewing_note is not None:
                self.midi_manager.note_off(self.previewing_note)

            # Use the passed velocity instead of the default
            self.midi_manager.note_on(midi_note, velocity)
            self.previewing_note = midi_note

    def copy(self):
        if self.selected_notes:
            # Find the earliest note to use as a relative anchor for pasting
            min_x = min(n.x for n in self.selected_notes)
            self.clipboard = []
            for n in self.selected_notes:
                # Store properties as a dict or a new Note object
                self.clipboard.append({
                    'rel_x': n.x - min_x,
                    'y': n.y,
                    'length': n.length
                })

    def paste(self):
        if self.clipboard:
            self.midi_manager.save_history()  #
            self.selected_notes.clear()  #

            # Anchor the paste to the current playhead or mouse position
            paste_anchor = self.midi_manager.play_tick  #

            for data in self.clipboard:
                new_note = Note(
                    paste_anchor + data['rel_x'],
                    data['y'],
                    data['length']
                )
                self.midi_manager.add_note(new_note)  #
                self.selected_notes.append(new_note)  #

    def get_grid_coords(self, pos):
        """Returns (snapped_ticks, y_index)"""
        raw_x_pixels = pos[0] + self.offset_x - self.roll_x
        raw_ticks = self.pixel_to_ticks(raw_x_pixels)
        snapped_ticks = self.get_snapped_ticks(raw_ticks)

        grid_y = (pos[1] + self.offset_y - self.roll_y) // self.cell_h
        return snapped_ticks, int(grid_y)

    def sync_project_boundaries(self):
        # This is called every frame in draw()
        # It updates the scrollbar UI based on the Manager's 'Truth'
        new_content_px = self.ticks_to_pixel(self.midi_manager.project_end_tick)

        if self.h_scroll.content_size != new_content_px:
            self.h_scroll.content_size = new_content_px

    def update_auto_scroll(self):

        if self.h_scroll.dragging or self.dragging_scroll or self.dragging_playhead:
            return
        if not self.midi_manager.playing:
            return

        current_tick = self.midi_manager.play_tick

        # Check if playhead jumped back (Loop detected)
        if current_tick < self.last_frame_tick and self.midi_manager.playing:
            self.offset_x = 0
            self.h_scroll.offset = 0
            self.grid_needs_update = True
            self.notes_need_update = True

        self.last_frame_tick = current_tick
        center_x = self.roll_w // 2 - self.offset_x

        if self.current_playhead_px > center_x:
            new_offset = self.current_playhead_px - center_x
            # Clamp to project end

            old_offset = self.offset_x
            max_offset = self.h_scroll.content_size - self.roll_w
            self.offset_x = max(0, min(new_offset, max_offset))
            self.h_scroll.offset = self.offset_x
            if old_offset!=self.offset_x:
                self.grid_needs_update = True
                self.notes_need_update = True


    def update_zoom(self):
        if abs(self.cell_w - self.target_cell_w) > 0.001:
            # --- CALCULATE DYNAMIC LIMITS ---
            self.update_lod()
            # Max Zoom: 2 bars fill the width (roll_w)
            beats_in_2_bars = 2 * self.midi_manager.time_signature[0]
            self.max_cell_w = self.roll_w / max(1, beats_in_2_bars)

            # Min Zoom: The current 8-bar window fits the width
            # total_project_ticks is updated in sync_project_boundaries
            self.min_cell_w = self.roll_w / max(0.1, self.midi_manager.total_beats)

            # Apply Clamping to target
            self.target_cell_w = max(self.min_cell_w, min(self.target_cell_w, self.max_cell_w))

            # --- ANIMATION LOGIC ---
            old_anchor_px = self.ticks_to_pixel(self.zoom_anchor_tick)
            self.cell_w += (self.target_cell_w - self.cell_w) * self.zoom_speed
            new_anchor_px = self.ticks_to_pixel(self.zoom_anchor_tick)

            # Adjust offset to keep mouse centered
            self.offset_x += (new_anchor_px - old_anchor_px)

            # Final Boundary Check
            max_scroll = max(0, self.h_scroll.content_size - self.roll_w)
            self.offset_x = max(0, min(self.offset_x, max_scroll))
            self.h_scroll.offset = self.offset_x
            self.grid_needs_update = True
            self.notes_need_update = True


        else:
            self.cell_w = self.target_cell_w


    def update_lod(self):
        """Calculates grid density and label steps based on current zoom."""
        ticks_per_bar = self.midi_manager.ticks_per_bar
        pixels_per_bar = self.ticks_to_pixel(ticks_per_bar)
        active_res = self.midi_manager.steps_per_beat

        # Calculate how many bars fit on the screen
        visible_bars = self.roll_w / max(1 , pixels_per_bar)
        # Thresholds for grid lines
        self.draw_32nds = (visible_bars <= 5) and (active_res >= 8)
        self.draw_16ths = self.draw_32nds or (visible_bars <= 8 and active_res >= 4)
        self.draw_8ths = self.draw_16ths or (visible_bars <= 16) and (active_res >= 2)
        self.draw_beats = self.draw_8ths or (visible_bars <= 64)
        self.draw_measure = self.draw_beats or (visible_bars <= 128)

        # Thresholds for bar labels
        if visible_bars <= 32:
            self.label_step = 1
        elif visible_bars <= 64:
            self.label_step = 2
        elif visible_bars <= 128:
            self.label_step = 4
        else:
            self.label_step = 8


    def fit_to_bars(self, num_bars=8):
        """Adjusts zoom so that exactly 'num_bars' fit in the viewport."""
        if self.roll_w <= 0: return  # Safety check for initialization

        # 1. Calculate total beats we want to see
        # Beats = Bars * Beats_Per_Bar (usually 4)
        total_beats_to_fit = num_bars * self.midi_manager.time_signature[0]

        # 2. Calculate the width each beat needs to be
        # cell_w = total_pixels / total_beats
        self.target_cell_w = self.roll_w / total_beats_to_fit

        # 3. Optional: Reset horizontal scroll to start
        self.offset_x = 0
        self.h_scroll.offset = 0

    def update_key_labels(self):
        """Refreshes the text on all piano key buttons based on the current key."""
        for i in range(128):
            midi_val = 127 - i
            new_name = get_note_name(midi_val, self.midi_manager.current_key)
            self.key_buttons[i].text = new_name



    def get_raw_ticks(self, mouse_x):
        """Returns the exact MIDI tick under the mouse without snapping."""
        raw_x_pixels = mouse_x + self.offset_x - self.roll_x
        return self.pixel_to_ticks(raw_x_pixels)

    def update_scale_mask(self):
        """
        Pre-calculates which of the 128 notes are in the current scale.
        Call this only when the Key or Scale changes.
        """
        if self.midi_manager.current_key == "None":
            self.scale_mask = [
                True
                for i in range(128)
            ]
            return
        parts = self.midi_manager.current_key.split()
        root_str = parts[0]
        type_str = parts[1]

        from Config import ROOT_OFFSETS, SCALE_INTERVALS  # Ensure these are imported
        root_val = ROOT_OFFSETS.get(root_str, 0)
        intervals = SCALE_INTERVALS.get(type_str, SCALE_INTERVALS["Major"])

        # Create a 128-bit mask where True means 'In Scale'
        self.scale_mask = [
            ((midi_note % 12 - root_val) % 12 in intervals)
            for midi_note in range(128)
        ]

    def update_grid(self):
        """Restores the full grid detail into the cached surface with viewport culling."""
        self.grid_surface.fill(WHITE)

        # 1. SETUP VISIBILITY RANGE
        # Use the pre-calculated start and end ticks to avoid drawing off-screen lines
        visible_start_tick = self.start_tick
        visible_end_tick = self.end_tick
        ticks_per_bar = self.midi_manager.ticks_per_bar

        # 2. HORIZONTAL GRID (Pitch Rows & Scale Shading)
        # Only iterate through the notes currently visible vertically
        start_note_idx = int(self.offset_y // self.cell_h)
        end_note_idx = int((self.offset_y + self.roll_h) // self.cell_h) + 1

        for n in range(start_note_idx, min(128, end_note_idx)):
            py = n * self.cell_h - self.offset_y
            midi_note_num = 127 - n

            # Draw Scale Backgrounds (only if note is not in the current scale mask)
            if not self.scale_mask[midi_note_num]:
                pygame.draw.rect(self.grid_surface, (220, 220, 220), (0, py, self.roll_w, self.cell_h))

            # Row separator line
            pygame.draw.line(self.grid_surface, (220, 220, 220), (0, py), (self.roll_w, py), 1)

        # 3. VERTICAL GRID (Time Lines)
        # Determine the smallest resolution we need to draw based on zoom
        # Logic: 32nd > 16th > 8th > Beat > Bar
        step_ticks = PPQ // 4  # Default to 16th notes
        if self.draw_32nds:
            step_ticks = PPQ // 8
        elif not self.draw_16ths and self.draw_8ths:
            step_ticks = PPQ // 2
        elif not self.draw_8ths:
            step_ticks = PPQ

        # SNAP the start of our loop to the nearest grid step before the visible area
        first_line_tick = (visible_start_tick // step_ticks) * step_ticks

        # Iterate ONLY through the visible horizontal area
        for t in range(int(first_line_tick), int(visible_end_tick) + step_ticks, int(step_ticks)):
            px = self.ticks_to_pixel(t) - self.offset_x

            # Skip lines that are mathematically slightly off-screen due to float precision
            if px < 0 or px > self.roll_w:
                continue

            # Determine line priority (Bar > Beat > Sub-division)
            if t % ticks_per_bar == 0 and self.draw_measure:
                pygame.draw.line(self.grid_surface, BLACK, (px, 0), (px, self.roll_h), 2)
            elif t % PPQ == 0 and self.draw_beats:
                pygame.draw.line(self.grid_surface, DARK_GRAY, (px, 0), (px, self.roll_h), 1)
            elif t % (PPQ // 2) == 0 and self.draw_8ths:
                pygame.draw.line(self.grid_surface, (180, 180, 180), (px, 0), (px, self.roll_h), 1)
            elif t % (PPQ // 4) == 0 and self.draw_16ths:
                pygame.draw.line(self.grid_surface, (200, 200, 200), (px, 0), (px, self.roll_h), 1)
            elif t % (PPQ // 8) == 0 and self.draw_32nds:
                pygame.draw.line(self.grid_surface, (200, 200, 200), (px, 0), (px, self.roll_h), 1)

        self.grid_needs_update = False

    def update_notes_layer(self):
        """Redraws all notes to a cached surface. Only called when data changes."""
        self.notes_surface.fill((0, 0, 0, 0))  # Clear with transparency

        num_tracks = len(self.midi_manager.tracks)
        # Draw background tracks (unselected)
        for i in range(num_tracks):
            if i != self.midi_manager.active_track_index:
                self._render_track_layer(self.notes_surface, i, self.start_tick, self.end_tick, alpha=100)

        # Draw foreground tracks (selected)
        self._render_track_layer(self.notes_surface, self.midi_manager.active_track_index, self.start_tick, self.end_tick, alpha=255)

        self.notes_need_update = False

    def _render_track_layer(self, dest_surface, track_idx, start_t, end_t, alpha):
        """
        Modified to support local coordinate blitting for the cached surface.
        """
        track_notes = self.midi_manager.tracks[track_idx]
        if not track_notes: return

        color = TRACK_COLORS[track_idx % len(TRACK_COLORS)]
        search_back_limit = start_t - self.midi_manager.max_note_length
        start_idx = bisect.bisect_left(track_notes, search_back_limit, key=lambda n: n.x)
        end_idx = bisect.bisect_right(track_notes, end_t, key=lambda n: n.x)

        for i in range(start_idx, end_idx):
            note = track_notes[i]

            dw = max(1, self.ticks_to_pixel(note.length))

            note.draw(
                dest_surface,
                self.ticks_to_pixel(note.x) - self.offset_x,
                (note.y * self.cell_h) - self.offset_y,
                dw,
                self.cell_h,
                color=color,
                is_selected=(note in self.selected_notes),
                alpha=alpha
            )
        if self.midi_manager.recording:
            for note_num, active_note in self.midi_manager.active_recording_notes.items():
                live_length = max(10, self.midi_manager.play_tick - active_note.x)
                draw_x = self.ticks_to_pixel(active_note.x) - self.offset_x
                draw_y = (active_note.y * self.cell_h) - self.offset_y
                abs_w = self.ticks_to_pixel(live_length)

                active_note.draw(
                    dest_surface, draw_x, draw_y, max(1, abs_w), self.cell_h, color=(255, 100, 100), is_selected=False
                )

    def draw_roll(self, dest_surface):
        """Optimized draw loop using cached surfaces."""
        if self.grid_needs_update:
            self.update_grid()

        # Trigger note cache update if dirty
        if self.notes_need_update or self.midi_manager.recording or any(n.dragging or n.resizing for n in self.midi_manager.notes):

            self.update_notes_layer()


        # Blit static layers
        dest_surface.blit(self.grid_surface, (self.roll_x, self.roll_y))
        dest_surface.blit(self.notes_surface, (self.roll_x, self.roll_y))

        if 0 <= self.current_playhead_px <= self.roll_w:
            pygame.draw.line(dest_surface, RED,
                             (self.roll_x + self.current_playhead_px, self.roll_y),
                             (self.roll_x + self.current_playhead_px, self.roll_y + self.roll_h), 2)

        if self.selection_rect:
            temp_surf = pygame.Surface(self.selection_rect.size, pygame.SRCALPHA)
            temp_surf.fill((0, 120, 255, 50))
            dest_surface.blit(temp_surf, self.selection_rect.topleft)
            pygame.draw.rect(dest_surface, (0, 120, 255), self.selection_rect, 1)


    def zoom_in(self):
        """Reduces the visible area by approximately one bar."""
        current_bars = self.get_visible_bar_count()
        # Target one less bar, but stay at a minimum of 1 bar
        target = max(1, round(current_bars - 1))

        self.fit_to_bars(target)
        self.notes_need_update = True
        self.grid_needs_update = True

    def zoom_out(self):
        """Increases the visible area by exactly one bar."""
        current_bars = self.get_visible_bar_count()
        # Target one more bar
        target = round(current_bars + 1)

        self.fit_to_bars(target)
        self.notes_need_update = True
        self.grid_needs_update = True

    def get_visible_bar_count(self):
        """Calculates how many bars currently fit in the roll width."""
        ticks_per_bar = self.midi_manager.ticks_per_bar
        pixels_per_bar = self.ticks_to_pixel(ticks_per_bar)
        if pixels_per_bar <= 0: return 8
        return self.roll_w / pixels_per_bar

    def undo(self):
        self.midi_manager.undo()
        self.notes_need_update = True

    def redo(self):
        self.midi_manager.redo()
        self.notes_need_update = True