Enhances edge scrolling logic to prevent over-scrolling
by checking boundaries based on dragged element position.
This prevents scrolling past the top or bottom edges
of the time grid during drag operations.
Also adds debugging logs for scroll check.
Moves event hover handling from DragDropManager to a new DragHoverManager.
This improves separation of concerns and makes the hover logic more modular and reusable. The DragHoverManager is now responsible for tracking when the mouse hovers over events, and it emits events for other parts of the application to react to.
The drag:start event is used to deactivate hover tracking when a drag operation starts.
Improves user experience by animating the dragged element back to its original position when the drag operation is cancelled due to the mouse leaving the grid container.
Resets scroll state and stops edge scrolling when a drag event converts between all-day and timed events, preventing unexpected scrolling behavior during conversion.
Refactors drag scroll compensation to use a direct scroll delta instead of accumulating the scroll.
This improves accuracy and responsiveness during drag operations when the scrollable content is being scrolled. It now updates the target position immediately as the user scrolls.
Enhances drag-and-drop functionality by accurately compensating for scroll during drag operations.
This ensures the dragged element remains correctly positioned relative to the mouse,
even when the user scrolls the content during the drag.
It achieves this by:
- Tracking whether scrolling has occurred during a drag operation.
- Factoring scroll delta into target position calculation.
- Updating targetY/currentY instead of directly manipulating the clone's style.
Improves edge scroll detection by listening for actual scroll events instead of relying on mouse position.
This change ensures that the 'edgescroll:started' event is only emitted when scrolling has actually begun, preventing false positives and improving the accuracy of scroll compensation. It also removes the unnecessary scroll listener from the DragDropManager, consolidating scroll handling in the EdgeScrollManager.
Enhances the drag and drop experience by integrating edge scrolling,
allowing users to scroll the calendar view while dragging events.
Fixes issues with event positioning during scrolling by compensating
for scroll changes during drag operations. Also, adds mock events
to data.
Refactors drag and drop event handling for smoother updates.
Tracks the current mouse position during drag operations to improve the accuracy of position updates.
Adjusts edge scrolling behavior.
Refactors drag and drop to use the original element as the source and introduces edge scrolling.
This change aims to enhance the user experience during drag and drop operations by ensuring the correct element is used as the source, fixing issues, and by automatically scrolling the view when the dragged element reaches the edge of the scrollable area.
Adds edge scrolling to automatically scroll the calendar
when dragging an event near the edges of the view.
This improves the drag-and-drop experience by allowing users
to move events beyond the visible area.
Removes auto-scroll logic from the event renderer, centralizing
the scrolling behavior within the new edge scroll manager.
Removes the auto-scroll feature from the drag and drop manager.
This simplifies the drag and drop interactions by removing the need to automatically scroll the content area during drag operations. The scroll container, related properties, and auto-scroll logic have been removed.
Also, the mouse enter logic was moved to handleEventMouseEnter function.
Streamlines drag and drop logic by removing unnecessary state variables
and simplifying column change handling, enhancing performance
and code maintainability.
Ensures drag:move events are emitted during the animation loop
for smoother and more consistent updates during drag operations.
Removes redundant emission from the main drag handling logic.
Streamlines the conversion of all-day events to timed events during drag and drop operations. This change improves the event rendering process by ensuring proper handling of element replacement and position updates.
Removes redundant code and simplifies the logic for updating the dragged clone.
Allows users to convert all-day events to timed events by dragging them over a day column.
This implementation adds logic to the DragDropManager to detect when an all-day event is dragged over a column.
It then emits a new event, 'drag:mouseenter-column', carrying the event data and target column information.
The event rendering service handles this event.
Enhances the visual feedback during and after event drag and drop operations in the calendar.
- Preserves the full opacity of the dragged event clone during the drag operation for better visibility.
- Applies a highlight class to the event after it's dropped to visually indicate the new location.
- Adds specific styling for the highlighted state based on event type.
Improves event dragging by tracking the source column and using the updated event data for re-rendering affected columns.
Also, enhances event resizing by updating the event data and re-rendering the column to recalculate stacking/grouping.
Uses snap interval as minimum duration when resizing.
Replaces the previous rough event resizing implementation with a smooth, animated approach.
Uses pointer events for accurate tracking and adds a visual resize handle
for better user interaction.
Also refactors drag and drop to exclude resize handle.
Refines drag and drop functionality by calculating position relative to the column during drag and snapping to the grid on mouse up, resulting in more precise placement.
Addresses an issue where the dragged element's position was not correctly calculated relative to the target column.
Implements a smooth drag animation for a more fluid user experience.
Instead of directly snapping to the mouse position, it interpolates
the position over time using `requestAnimationFrame`. This provides
a visually smoother movement during drag operations.
Uses CSS classes for event hover highlighting,
instead of directly manipulating the background color.
This allows for more flexible and maintainable styling.
Re-enables resize handle manager.
Removes console logs.
Enhances the resize handle indicator for calendar events by using cached event elements for efficiency.
This eliminates the need to constantly query the DOM, and only refreshes the cache on relevant event changes.
Additionally updates the resize indicator style for improved visual clarity and user experience.
Adds a resize handle manager to handle mouse hover
effects on calendar events and display a resize indicator.
This allows users to visually identify and initiate
event resizing by hovering near the bottom edge of an event.
Refactors the event layout and stacking logic based on review feedback.
This includes:
- Merging conflicting event groups to prevent inconsistencies.
- Implementing minimal stack level assignment using a min-heap.
- Consolidating styling and using DateService for drag operations.
- Adding reflow after drag and drop.
- Improving the column event filtering to include events overlapping midnight.
- Ensuring explicit sorting of events for grid layout.
Refines the event grid layout algorithm to more accurately
identify conflicting events for stacking within the grid.
Now uses an expanding search to find chains of conflicting events,
ensuring that all events that should be grouped together are
correctly identified.
Introduces a coordinator to manage event layout calculations,
separating this logic from rendering.
It calculates stack levels and allocates event columns for
improved visual organization of calendar events.
Moves complex layout determination logic (grid grouping, stack levels, positioning) from `EventRenderer` to a new `EventLayoutCoordinator` class.
Delegates layout responsibilities to the coordinator, significantly simplifying the `EventRenderer`'s `renderColumnEvents` method. Refines `EventStackManager` by removing deprecated layout methods, consolidating its role to event grouping and core stack level management.
Improves modularity and separation of concerns within the rendering pipeline.
Introduces a 3-phase algorithm in `EventStackManager` for dynamic event positioning. Groups events by start time proximity to determine optimal layout.
Optimizes horizontal space by using side-by-side grid columns for simultaneous events and allowing non-overlapping events to share stack levels. Supports nested stacking for late-arriving events within grid columns.
Includes comprehensive documentation (`STACKING_CONCEPT.md`) and a visual demonstration (`stacking-visualization.html`) to explain the new layout logic. Updates event rendering to utilize the new manager and adds extensive test coverage.
Introduces a polymorphic `createClone` method on base event elements to customize clone generation.
Adds a `replaceClone` delegate to drag event payloads, enabling subscribers to dynamically swap the active dragged clone.
This supports scenarios like converting a standard event clone to an all-day event clone when dragging to the all-day header.
Improves efficiency and reliability of drag-and-drop operations involving calendar headers.
Transitions from continuous polling within `handleMouseMove` to using native `mouseenter` and `mouseleave` events with delegation on `swp-calendar-header` elements. This change ensures more precise and performant detection of header interactions during a drag.
Also enhances the initial event detection logic to correctly identify `SWP-ALLDAY-EVENT` elements when starting a drag.
Introduces web components for event elements, separating timed and all-day events into distinct components for better organization and reusability.
This change also simplifies event rendering and drag-and-drop operations by leveraging the properties and lifecycle methods of web components.
Enhances date validation and timezone handling using DateService, ensuring data integrity and consistency.
Refactors event rendering and dragging to correctly handle date transformations.
Adds a test plan for event stacking and z-index management.
Fixes edge cases in navigation and date calculations for week/year boundaries and DST transitions.
Standardizes date manipulation across the application by leveraging the DateService.
This change improves consistency and reduces code duplication by removing redundant date calculations.
Replaces DateCalculator with DateService for improved date and time operations, including timezone handling.
This change enhances the calendar's accuracy and flexibility in managing dates, especially concerning timezone configurations.
It also corrects a typo in the `allDay` dataset attribute.
Addresses issues with all-day event duration calculation and positioning during drag and drop.
- Uses `differenceInCalendarDays` to correctly calculate event duration across timezone and DST boundaries.
- Preserves the original event time when moving events to a different day.
- Snaps dragged event to the top of the target time slot.
Ensures all-day events maintain their original duration
when dragged and dropped to a new date.
Calculates and applies the correct end date based on the
original event's span.
Addresses issues with dragging all-day events, ensuring correct event placement and layout calculations after a drag and drop operation.
Specifically, ensures the correct event ID is used and updates the event layout when dragging all day events.
Refines drag and drop behavior for all-day events.
Removes unnecessary logging and conditional logic in the
AllDayManager.
Simplifies column change handling in the EventRendererManager.
Ensures that the all-day event overflow indicator updates
correctly when the number of events changes, instead of
creating duplicate indicators.
Removes unused event click handling logic.
