Hi,
This could be a possible implementation of the ScrollIndexToSelection bead:

package xxxx.jewel.beads.controls.list
{
        import org.apache.royale.core.IBead;
        import org.apache.royale.core.IStrand;
        import org.apache.royale.events.Event;
        import org.apache.royale.events.IEventDispatcher;
        import org.apache.royale.jewel.beads.views.IScrollToIndexView;
        import org.apache.royale.core.ISelectionModel;
        import org.apache.royale.core.UIBase;
        
        /**
         *  The ScrollIndexToSelection bead is a specialty bead that can be 
used with
         *  Jewel List List control to make sure that whenever the selected 
item changes it becomes visible.
         *  
         *  @langversion 3.0
         *  @playerversion Flash 10.2
         *  @playerversion AIR 2.6
         *  @productversion Royale 0.9.8
         */
        public class ScrollIndexToSelection implements IBead
        {
                /**
                 *  constructor.
                 *
                 *  @langversion 3.0
                 *  @playerversion Flash 10.2
                 *  @playerversion AIR 2.6
                 *  @productversion Royale 0.9.8
                 */
                public function ScrollIndexToSelection()
                {
                }
                
                protected var _strand:IStrand;
                
                /**
                 *  @copy org.apache.royale.core.IBead#strand
                 *  
                 *  @langversion 3.0
                 *  @playerversion Flash 10.2
                 *  @playerversion AIR 2.6
                 *  @productversion Royale 0.9.8
                 */
                public function set strand(value:IStrand):void
                {
                        _strand = value;                        
                                
IEventDispatcher(_strand).addEventListener("selectionChanged", 
selectionChangeHandler);
                }

                /**
                 *  Ensures that the data provider item at the given index is 
visible.
                 */
                        private function selectionChangeHandler(ev:Event):void
                {                       
                        var host:UIBase = UIBase(_strand);
                        if(!host)
                                return;

                        if(host.view && host.view is IScrollToIndexView)
                        {
                                if(host.model && host.model is ISelectionModel)
                                {
                                        var setIndex:int = (host.model as 
ISelectionModel).selectedIndex;
                                        (host.view as 
IScrollToIndexView).scrollToIndex(setIndex);                                    
  
                                }
                        }
                 }
        }
}

The bead works, but the user experience is bad, too many jumps / scrolls ...
They say that ignorance is very daring, you have to forgive me 😝 ... this is 
how I see it:
The selectionChanged event of the List is dispatched when the selectedIndex of 
the model is explicitly set and this occurs in at least 3 scenarios:
1- Assignment by code, valueCommit
2- Click on an itemRenderer
3- And when we move with the keyboard (key down / up)
Of these three scenarios I think that the only one that should be controlled is 
1, why? Because when clicked, the item is visible and, when we move with the 
keyboard the
ListKeyDownController, after modifying the selectedIndex, explicitly calls 
scrollToIndex. Could scenario 1, valueCommit, be differentiated from the rest?

If the double positioning that occurs in scenarios 2 and 3 could not be 
avoided, we could "hide" it by overriding the scrollToIndex function so that it 
does not make the scroll change if the item is visible at that moment.

As you see?

Thx.
Hiedra

-----Mensaje original-----
De: Carlos Rovira <[email protected]> 
Enviado el: miércoles, 4 de noviembre de 2020 11:16
Para: Apache Royale Development <[email protected]>
Asunto: Re: Jewel List - selectionChange (Bis)

Yeah, I think it should be pretty straight forward.
For example a name could be "ScrollIndexToSelection" in the "
org.apache.royale.jewel.beads.controls.list" package.
Then it just listen for selectionChange event and do the scrollToIndex

thanks!

El mié., 4 nov. 2020 a las 10:40, Maria Jose Esteve (<[email protected]>)
escribió:

> Right Carlos. If the guideline is that the operation should be the 
> same, basically, I also think it should be a bead, since the 
> application of the scrollToIndex, whenever the selected element is 
> changed, it would be a sudden change.
>
>
>
> Would we agree to add this functionality in a bead?
>
> If you tell me yes, I try 😝
>
>
>
> Thx.
>
> Hiedra
>
> -----Mensaje original-----
> De: Carlos Rovira <[email protected]> Enviado el: miércoles, 4 
> de noviembre de 2020 10:02
> Para: Apache Royale Development <[email protected]>
> Asunto: Re: Jewel List - selectionChange (Bis)
>
>
>
> Hi Maria Jose,
>
>
>
> so if I'm understanding correctly, we currently have the same 
> behaviour as Flex (maybe we need to update a bit to improve over time, 
> but in essence is the same): Moving with keys trigger the 
> scrollToIndex, but if we use programmatically selectedItem, the scrollToIndex 
> is not triggered, right?
>
>
>
> If so I think we are ok in the TLC List, and the behaviour should go 
> to a bead.
>
>
>
> Can you confirm?
>
>
>
> thanks
>


--
Carlos Rovira
Apache Member & Apache Royale PMC
*Apache Software Foundation*
http://about.me/carlosrovira

Reply via email to