@@ -71,37 +71,46 @@ public fun <Item> Modifier.gridDragSelect(
7171 if (! enableHaptics) null
7272 else hapticFeedback ? : GridDragSelectDefaults .hapticsFeedback
7373
74+ val isSelected: (Item ) -> Boolean = { item ->
75+ state.selected.contains(item)
76+ }
77+
7478 pointerInput(Unit ) {
7579 detectDragGesturesAfterLongPress(
7680 onDragStart = { offset ->
7781 state.gridState.itemIndexAtPosition(offset)?.let { startIndex ->
7882 val item = items.getOrNull(startIndex)
7983 if (item != null && state.selected.contains(item).not ()) {
8084 haptics?.performHapticFeedback(HapticFeedbackType .LongPress )
81- state.initialIndex = startIndex
82- state.addSelected(item)
85+ state.startDrag(item, startIndex)
8386 }
8487 }
8588 },
86- onDragCancel = state::resetDrag ,
87- onDragEnd = state::resetDrag ,
89+ onDragCancel = state::stopDrag ,
90+ onDragEnd = state::stopDrag ,
8891 onDrag = { change, _ ->
89- state.withInitialIndex { initial ->
92+ state.whenDragging { dragState ->
9093 autoScrollSpeed.value = gridState.calculateScrollSpeed(change, scrollThreshold)
9194
92- val newSelected =
93- gridState.getSelectedByPosition(items, initial, change)
94- ? : gridState.getOverscrollItems(items, initial, change)
95+ val itemPosition = gridState.getItemPosition(change.position)
96+ ? : return @whenDragging
9597
96- if (newSelected != null ) {
97- updateSelected(newSelected )
98- }
98+ val newSelection = items.getSelectedItems(itemPosition, dragState, isSelected)
99+ updateDrag(current = itemPosition )
100+ updateSelected(newSelection)
99101 }
100102 },
101103 )
102104 }
103105}
104106
107+ /* *
108+ * Calculates the auto-scroll speed based on the current drag position.
109+ *
110+ * @param[change] The [PointerInputChange] for the current drag position.
111+ * @param[scrollThreshold] The distance from the edge of the grid to start auto-scrolling.
112+ * @return The auto-scroll speed.
113+ */
105114private fun LazyGridState.calculateScrollSpeed (
106115 change : PointerInputChange ,
107116 scrollThreshold : Float ,
@@ -116,6 +125,12 @@ private fun LazyGridState.calculateScrollSpeed(
116125 }
117126}
118127
128+ /* *
129+ * Gets the index of the item that was hit by the drag.
130+ *
131+ * @param[hitPoint] The point where the drag hit the grid.
132+ * @return The index of the item that was hit by the drag.
133+ */
119134private fun LazyGridState.itemIndexAtPosition (hitPoint : Offset ): Int? {
120135 val found = layoutInfo.visibleItemsInfo.find { itemInfo ->
121136 itemInfo.size.toIntRect().contains(hitPoint.round() - itemInfo.offset)
@@ -124,36 +139,58 @@ private fun LazyGridState.itemIndexAtPosition(hitPoint: Offset): Int? {
124139 return found?.index
125140}
126141
127- private fun <Item > LazyGridState.getSelectedByPosition (
128- items : List <Item >,
129- initialIndex : Int ,
130- change : PointerInputChange ,
131- ): List <Item >? {
132- val itemAtPosition = itemIndexAtPosition(change.position) ? : return null
133- return items.filterIndexed { index, _ ->
134- index in initialIndex.. itemAtPosition || index in itemAtPosition.. initialIndex
135- }
142+ /* *
143+ * Gets the index of the item that was hit by the drag.
144+ *
145+ * @param[hitPoint] The point where the drag hit the grid.
146+ * @return The index of the item that was hit by the drag, or the index of the last item if the
147+ * drag has gone past the last item.
148+ */
149+ private fun LazyGridState.getItemPosition (hitPoint : Offset ): Int? {
150+ return itemIndexAtPosition(hitPoint)
151+ ? : if (isPastLastItem(hitPoint)) layoutInfo.totalItemsCount - 1 else null
136152}
137153
138154/* *
139- * Get the items that are overscrolled when dragging .
155+ * Determines if the drag has gone past the last item in the list .
140156 *
141- * If the user has dragged past the last item in the list, this will return all items after the
142- * initial index .
157+ * @param[hitPoint] The point where the drag hit the grid.
158+ * @return True if the drag has gone past the last item in the list, false otherwise .
143159 */
144- private fun <Item > LazyGridState.getOverscrollItems (
145- items : List <Item >,
146- initialIndex : Int ,
147- change : PointerInputChange ,
148- ): List <Item >? {
160+ private fun LazyGridState.isPastLastItem (hitPoint : Offset ): Boolean {
149161 // Get the last item in the list
150162 val lastItem = layoutInfo.visibleItemsInfo.lastOrNull()
151163 ?.takeIf { it.index == layoutInfo.totalItemsCount - 1 }
152- ? : return null
164+ ? : return false
153165
154166 // Determine if we have dragged past the last item in the list
155- return if (change.position.y > lastItem.offset.y) {
156- // If we have, return all items after the initial index
157- items.filterIndexed { index, _ -> index >= initialIndex }
158- } else null
167+ return hitPoint.y > lastItem.offset.y
168+ }
169+
170+ /* *
171+ * Gets a list of items that are selected based on the current drag state.
172+ *
173+ * @receiver The list of items in the grid.
174+ * @param[itemPosition] The position of the item that was hit by the drag.
175+ * @param[dragState] The current drag state.
176+ * @param[isSelected] A function to determine if an item is selected.
177+ * @return A list of items that are selected based on the current drag state.
178+ */
179+ private fun <Item > List<Item>.getSelectedItems (
180+ itemPosition : Int ,
181+ dragState : DragState ,
182+ isSelected : (Item ) -> Boolean ,
183+ ): List <Item > {
184+ val (initial, current) = dragState
185+ return filterIndexed { index, item ->
186+ // Determine if the item is within the drag range
187+ val withinRange = index in initial.. itemPosition || index in itemPosition.. initial
188+
189+ // Determine if the item was previously selected and is still within the drag range
190+ val selected = isSelected(item)
191+ val previouslySelectedInRange =
192+ selected && index !in initial.. current && index !in current.. initial
193+
194+ withinRange || previouslySelectedInRange
195+ }
159196}
0 commit comments