@jetdv

Hi sir..

need your help ...

look at this clip how my script is working and where is error..

sorry for my English

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using ScriptPortal.Vegas;

public class EntryPoint
{
    public void FromVegas(Vegas vegas)
    {
        PNGSetting(vegas);
    }

    private void PNGSetting(Vegas vegas)
    {
        try
        {
            // Ensure there are at least one marker
            int markerCount = vegas.Project.Markers.Count;

            if (markerCount < 1)
            {
                MessageBox.Show("At least one marker is required.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            // Get the positions of the first and second markers if they exist
            Timecode firstMarkerPosition = vegas.Project.Markers[0].Position;
            Timecode secondMarkerPosition = markerCount > 1 ? vegas.Project.Markers[1].Position : Timecode.FromSeconds(0);

            // Process events before the first marker
            DeselectEvents(vegas);
            SelectEventsInRange(vegas, Timecode.FromSeconds(0), firstMarkerPosition);
            SetEventsLength(vegas);

            if (markerCount > 1)
            {
                // Process events between the first and second markers
                DeselectEvents(vegas);
                SelectEventsInRange(vegas, firstMarkerPosition, secondMarkerPosition);
                SetEventsLength(vegas);

                // Process events after the second marker
                DeselectEvents(vegas);
                SelectEventsInRange(vegas, secondMarkerPosition, null);
                SetEventsLength(vegas);
            }
            else
            {
                // Process events after the first marker only if there is only one marker
                DeselectEvents(vegas);
                SelectEventsInRange(vegas, firstMarkerPosition, null);
                SetEventsLength(vegas);
            }

            // Final cleanup
            DeselectEvents(vegas);
            vegas.UpdateUI();
        }
        catch (Exception ex)
        {
            MessageBox.Show("Error: " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    private void DeselectEvents(Vegas vegas)
    {
        foreach (Track track in vegas.Project.Tracks)
        {
            foreach (TrackEvent trackEvent in track.Events)
            {
                trackEvent.Selected = false;
            }
        }
    }

    private void SelectEventsInRange(Vegas vegas, Timecode start, Timecode end)
    {
        foreach (Track track in vegas.Project.Tracks)
        {
            foreach (TrackEvent trackEvent in track.Events)
            {
                // Check if the event is within the range
                bool inRange =
                    (start == null || trackEvent.Start >= start) &&
                    (end == null || trackEvent.Start < end);

                trackEvent.Selected = inRange;
            }
        }
    }

    private void SetEventsLength(Vegas vegas)
    {
        try
        {
            var selectedEventsByTrack = GetSelectedEventsByTrack(vegas);

            if (selectedEventsByTrack.Count == 0)
                return;

            var result = GetHighestTrackAndTotalLength(selectedEventsByTrack);
            Track highestTrack = result.Key;
            Timecode totalHighestEventLength = result.Value;

            if (highestTrack == null)
                return;

            AdjustEventLengths(selectedEventsByTrack, highestTrack, totalHighestEventLength);
            AdjustRegionEnd(vegas);

            vegas.UpdateUI();
        }
        catch (Exception ex)
        {
            MessageBox.Show("Error: " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    private Dictionary<Track, List<TrackEvent>> GetSelectedEventsByTrack(Vegas vegas)
    {
        var selectedEventsByTrack = new Dictionary<Track, List<TrackEvent>>();

        foreach (Track track in vegas.Project.Tracks)
        {
            foreach (TrackEvent trackEvent in track.Events)
            {
                if (trackEvent.Selected)
                {
                    if (!selectedEventsByTrack.ContainsKey(track))
                    {
                        selectedEventsByTrack[track] = new List<TrackEvent>();
                    }
                    selectedEventsByTrack[track].Add(trackEvent);
                }
            }
        }

        return selectedEventsByTrack;
    }

    private KeyValuePair<Track, Timecode> GetHighestTrackAndTotalLength(Dictionary<Track, List<TrackEvent>> selectedEventsByTrack)
    {
        Track highestTrack = null;
        Timecode totalHighestEventLength = Timecode.FromSeconds(0);

        foreach (var kvp in selectedEventsByTrack)
        {
            Track track = kvp.Key;

            // Identify the highest track based on index
            if (highestTrack == null || track.Index > highestTrack.Index)
            {
                highestTrack = track;
                totalHighestEventLength = Timecode.FromSeconds(0);

                // Calculate the total length of selected events for this track
                foreach (TrackEvent ev in kvp.Value)
                {
                    totalHighestEventLength += ev.Length;
                }
            }
        }

        return new KeyValuePair<Track, Timecode>(highestTrack, totalHighestEventLength);
    }

    private void AdjustEventLengths(Dictionary<Track, List<TrackEvent>> selectedEventsByTrack, Track highestTrack, Timecode totalHighestEventLength)
    {
        foreach (var kvp in selectedEventsByTrack)
        {
            Track track = kvp.Key;
            if (track == highestTrack) continue;

            Timecode totalPreviousLength = Timecode.FromSeconds(0);
            TrackEvent lastSelectedEvent = null;

            foreach (TrackEvent ev in kvp.Value)
            {
                if (lastSelectedEvent == null || ev.Start > lastSelectedEvent.Start)
                {
                    if (lastSelectedEvent != null)
                    {
                        totalPreviousLength += lastSelectedEvent.Length;
                    }
                    lastSelectedEvent = ev;
                }
                else
                {
                    totalPreviousLength += ev.Length;
                }
            }

            if (lastSelectedEvent != null)
            {
                Timecode newLength = totalHighestEventLength - totalPreviousLength;

                if (newLength > Timecode.FromSeconds(0))
                {
                    lastSelectedEvent.Length = newLength;
                }
            }
        }
    }

    private void AdjustRegionEnd(Vegas vegas)
    {
        var latestSelectedEvents = GetLastSelectedEvents(vegas);

        if (latestSelectedEvents.Count == 0) return;

        Timecode furthestEndTime = GetFurthestEndTime(latestSelectedEvents.Values);
        UpdateRegionEnd(vegas, furthestEndTime);
    }

    private Dictionary<Track, TrackEvent> GetLastSelectedEvents(Vegas vegas)
    {
        var lastSelectedEvents = new Dictionary<Track, TrackEvent>();

        foreach (Track track in vegas.Project.Tracks)
        {
            TrackEvent lastSelectedEvent = null;

            foreach (TrackEvent trackEvent in track.Events)
            {
                if (trackEvent.Selected)
                {
                    lastSelectedEvent = trackEvent;
                }
            }

            if (lastSelectedEvent != null)
            {
                lastSelectedEvents[track] = lastSelectedEvent;
            }
        }

        return lastSelectedEvents;
    }

    private Timecode GetFurthestEndTime(IEnumerable<TrackEvent> events)
    {
        Timecode furthestEndTime = Timecode.FromSeconds(0);

        foreach (TrackEvent trackEvent in events)
        {
            Timecode endTime = trackEvent.Start + trackEvent.Length;
            if (endTime > furthestEndTime)
            {
                furthestEndTime = endTime;
            }
        }

        return furthestEndTime;
    }

    private void UpdateRegionEnd(Vegas vegas, Timecode furthestEndTime)
    {
        Region latestRegion = null;

        foreach (Region region in vegas.Project.Regions)
        {
            if (region.Position < furthestEndTime)
            {
                if (latestRegion == null || region.Position > latestRegion.Position)
                {
                    latestRegion = region;
                }
            }
        }

        if (latestRegion != null)
        {
            latestRegion.Length = furthestEndTime - latestRegion.Position;
        }
    }
}